# 1 "klm/bklm/geometry/src/GeometryPar.cc"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 487 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "klm/bklm/geometry/src/GeometryPar.cc" 2
# 10 "klm/bklm/geometry/src/GeometryPar.cc"
# 1 "include/klm/bklm/geometry/GeometryPar.h" 1
# 12 "include/klm/bklm/geometry/GeometryPar.h"
# 1 "include/klm/bklm/geometry/Module.h" 1
# 12 "include/klm/bklm/geometry/Module.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 1 3
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/defs.h" 1 3
# 124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/requires_hosted.h" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/requires_hosted.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wvariadic-macros"

#pragma GCC diagnostic ignored "-Wc++11-extensions"
#pragma GCC diagnostic ignored "-Wc++23-extensions"
# 336 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  typedef long unsigned int size_t;
  typedef long int ptrdiff_t;


  typedef decltype(nullptr) nullptr_t;


#pragma GCC visibility push(default)


  extern "C++" __attribute__ ((__noreturn__, __always_inline__))
  inline void __terminate() noexcept
  {
    void terminate() noexcept __attribute__ ((__noreturn__,__cold__));
    terminate();
  }
#pragma GCC visibility pop
}
# 369 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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"))) { }
}
# 573 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
#pragma GCC visibility push(default)




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





    return __builtin_is_constant_evaluated();



  }
#pragma GCC visibility pop
}
# 617 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
#pragma GCC visibility push(default)

  extern "C++" __attribute__ ((__noreturn__)) __attribute__((__cold__))
  void
  __glibcxx_assert_fail
    (const char* __file, int __line, const char* __function,
     const char* __condition)
  noexcept;
#pragma GCC visibility pop
}
# 648 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  __attribute__((__always_inline__,__visibility__("default")))
  inline void
  __glibcxx_assert_fail()
  { }
}
# 727 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/os_defines.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 392 "/usr/include/features.h" 3 4
# 1 "/usr/include/features-time64.h" 1 3 4
# 20 "/usr/include/features-time64.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 21 "/usr/include/features-time64.h" 2 3 4
# 1 "/usr/include/bits/timesize.h" 1 3 4
# 22 "/usr/include/features-time64.h" 2 3 4
# 393 "/usr/include/features.h" 2 3 4
# 468 "/usr/include/features.h" 3 4
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 469 "/usr/include/features.h" 2 3 4
# 490 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 551 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 552 "/usr/include/sys/cdefs.h" 2 3 4
# 1 "/usr/include/bits/long-double.h" 1 3 4
# 553 "/usr/include/sys/cdefs.h" 2 3 4
# 491 "/usr/include/features.h" 2 3 4
# 514 "/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
# 515 "/usr/include/features.h" 2 3 4
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/os_defines.h" 2 3
# 728 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
# 731 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 2 3
# 949 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/pstl_config.h" 1 3
# 950 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++config.h" 2 3



#pragma GCC diagnostic pop
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/requires_hosted.h" 2 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stringfwd.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stringfwd.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memoryfwd.h" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memoryfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memoryfwd.h" 3
  template<typename>
    class allocator;

  template<>
    class allocator<void>;



  template<typename, typename>
    struct uses_allocator;

  template<typename>
    struct allocator_traits;





}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stringfwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stringfwd.h" 3
  template<class _CharT>
    struct char_traits;

  template<> struct char_traits<char>;

  template<> struct char_traits<wchar_t>;


  template<> struct char_traits<char8_t>;



  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

}


  typedef basic_string<char> string;


  typedef basic_string<wchar_t> wstring;



  typedef basic_string<char8_t> u8string;




  typedef basic_string<char16_t> u16string;


  typedef basic_string<char32_t> u32string;





}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwchar" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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/include/bits/floatn.h" 1 3 4
# 119 "/usr/include/bits/floatn.h" 3 4
# 1 "/usr/include/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/bits/floatn-common.h" 3 4
# 1 "/usr/include/bits/long-double.h" 1 3 4
# 25 "/usr/include/bits/floatn-common.h" 2 3 4
# 214 "/usr/include/bits/floatn-common.h" 3 4
typedef float _Float32;
# 251 "/usr/include/bits/floatn-common.h" 3 4
typedef double _Float64;
# 268 "/usr/include/bits/floatn-common.h" 3 4
typedef double _Float32x;
# 285 "/usr/include/bits/floatn-common.h" 3 4
typedef long double _Float64x;
# 120 "/usr/include/bits/floatn.h" 2 3 4
# 31 "/usr/include/wchar.h" 2 3 4




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_wchar_t.h" 1 3 4
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 36 "/usr/include/wchar.h" 2 3 4


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 1 3 4
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg___gnuc_va_list.h" 1 3 4
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg___gnuc_va_list.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3 4
# 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


# 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;
# 50 "/usr/include/wchar.h" 2 3 4
# 79 "/usr/include/wchar.h" 3 4
extern "C" {



struct tm;



extern wchar_t *wcscpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern wchar_t *wcscat (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);


extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
   size_t __n) noexcept (true);



extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
    locale_t __loc) noexcept (true);

extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
     size_t __n, locale_t __loc) noexcept (true);




extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);



extern size_t wcsxfrm (wchar_t *__restrict __s1,
         const wchar_t *__restrict __s2, size_t __n) noexcept (true);







extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
        locale_t __loc) noexcept (true);




extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
    size_t __n, locale_t __loc) noexcept (true);


extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true)
  __attribute__ ((__malloc__)) ;
# 165 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));
# 175 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));





extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));




extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
     noexcept (true) __attribute__ ((__pure__));


extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
     noexcept (true) __attribute__ ((__pure__));
# 202 "/usr/include/wchar.h" 3 4
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
     noexcept (true) __attribute__ ((__pure__));
# 213 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
     noexcept (true) __attribute__ ((__pure__));



extern wchar_t *wcstok (wchar_t *__restrict __s,
   const wchar_t *__restrict __delim,
   wchar_t **__restrict __ptr) noexcept (true);


extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__));
# 234 "/usr/include/wchar.h" 3 4
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
     noexcept (true) __attribute__ ((__pure__));





extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
     noexcept (true) __attribute__ ((__pure__));
# 254 "/usr/include/wchar.h" 3 4
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
     noexcept (true) __attribute__ ((__pure__));



extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
    const wchar_t *__restrict __s2, size_t __n) noexcept (true);



extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true);


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true);




extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
     const wchar_t *__restrict __s2, size_t __n)
     noexcept (true);





extern wint_t btowc (int __c) noexcept (true);



extern int wctob (wint_t __c) noexcept (true);



extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
         const char *__restrict __s, size_t __n,
         mbstate_t *__restrict __p) noexcept (true);


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
         mbstate_t *__restrict __ps) noexcept (true);


extern size_t __mbrlen (const char *__restrict __s, size_t __n,
   mbstate_t *__restrict __ps) noexcept (true);
extern size_t mbrlen (const char *__restrict __s, size_t __n,
        mbstate_t *__restrict __ps) noexcept (true);







extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
 btowc (int __c) noexcept (true)
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
   ? (wint_t) __c : __btowc_alias (__c)); }

extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __inline __attribute__ ((__gnu_inline__)) int
 wctob (wint_t __wc) noexcept (true)
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
   ? (int) __wc : __wctob_alias (__wc)); }

extern __inline __attribute__ ((__gnu_inline__)) size_t
 mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true)

{ return (__ps != __null
   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }




extern size_t mbsrtowcs (wchar_t *__restrict __dst,
    const char **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) noexcept (true);



extern size_t wcsrtombs (char *__restrict __dst,
    const wchar_t **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) noexcept (true);





extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
     const char **__restrict __src, size_t __nmc,
     size_t __len, mbstate_t *__restrict __ps) noexcept (true);



extern size_t wcsnrtombs (char *__restrict __dst,
     const wchar_t **__restrict __src,
     size_t __nwc, size_t __len,
     mbstate_t *__restrict __ps) noexcept (true);






extern int wcwidth (wchar_t __c) noexcept (true);



extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true);





extern double wcstod (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr) noexcept (true);



extern float wcstof (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
extern long double wcstold (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
# 397 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) noexcept (true);



extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) noexcept (true);
# 412 "/usr/include/wchar.h" 3 4
extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);



extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
# 429 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, int __base) noexcept (true);



extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     noexcept (true);




__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, int __base)
     noexcept (true);



__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr,
     int __base) noexcept (true);





__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr, int __base)
     noexcept (true);



__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
           wchar_t **__restrict __endptr,
           int __base) noexcept (true);






extern long int wcstol_l (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr, int __base,
     locale_t __loc) noexcept (true);

extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr,
        int __base, locale_t __loc) noexcept (true);

__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
    wchar_t **__restrict __endptr,
    int __base, locale_t __loc) noexcept (true);

__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       int __base, locale_t __loc)
     noexcept (true);

extern double wcstod_l (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, locale_t __loc)
     noexcept (true);

extern float wcstof_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, locale_t __loc)
     noexcept (true);

extern long double wcstold_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);
# 512 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) noexcept (true);



extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) noexcept (true);
# 530 "/usr/include/wchar.h" 3 4
extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);



extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);
# 552 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src) noexcept (true);



extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true);
# 581 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern int fwide (__FILE *__fp, int __mode) noexcept (true);






extern int fwprintf (__FILE *__restrict __stream,
       const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
       const wchar_t *__restrict __format, ...)
     noexcept (true) ;





extern int vfwprintf (__FILE *__restrict __s,
        const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
        const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
     noexcept (true) ;






extern int fwscanf (__FILE *__restrict __stream,
      const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (const wchar_t *__restrict __s,
      const wchar_t *__restrict __format, ...)
     noexcept (true) ;
# 657 "/usr/include/wchar.h" 3 4
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, ...) noexcept (true) __asm__ ("" "__isoc99_swscanf")


                                                          ;
# 688 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
       const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (const wchar_t *__restrict __format,
      __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (const wchar_t *__restrict __s,
       const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     noexcept (true) ;







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) noexcept (true) __asm__ ("" "__isoc99_vswscanf")


                                                          ;
# 744 "/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);
# 799 "/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);
# 825 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 835 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
     __FILE *__restrict __stream);







extern int fputws_unlocked (const wchar_t *__restrict __ws,
       __FILE *__restrict __stream);






extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
   const wchar_t *__restrict __format,
   const struct tm *__restrict __tp) noexcept (true);




extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
     const wchar_t *__restrict __format,
     const struct tm *__restrict __tp,
     locale_t __loc) noexcept (true);
# 882 "/usr/include/wchar.h" 3 4
}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwchar" 2 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 137 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwchar" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::wint_t;

  using ::btowc;
  using ::fgetwc;
  using ::fgetws;
  using ::fputwc;
  using ::fputws;
  using ::fwide;
  using ::fwprintf;
  using ::fwscanf;
  using ::getwc;
  using ::getwchar;
  using ::mbrlen;
  using ::mbrtowc;
  using ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;

  using ::swprintf;

  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;

  using ::vfwscanf;


  using ::vswprintf;


  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;
  using ::wcsftime;
  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;

  using ::wcstof;

  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;
  using ::wcschr;
  using ::wcspbrk;
  using ::wcsrchr;
  using ::wcsstr;
  using ::wmemchr;


  inline wchar_t*
  wcschr(wchar_t* __p, wchar_t __c)
  { return wcschr(const_cast<const wchar_t*>(__p), __c); }

  inline wchar_t*
  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }

  inline wchar_t*
  wcsrchr(wchar_t* __p, wchar_t __c)
  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }

  inline wchar_t*
  wcsstr(wchar_t* __s1, const wchar_t* __s2)
  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }

  inline wchar_t*
  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }



}
}







namespace __gnu_cxx
{





  using ::wcstold;
# 262 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;
}
# 282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 3
  typedef long int streamoff;



#pragma GCC diagnostic pop


  typedef ptrdiff_t streamsize;
# 86 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      fpos(const fpos&) = default;
      fpos& operator=(const fpos&) = default;
      ~fpos() = default;



      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }





      fpos&
      operator+=(streamoff __off)
      {
 _M_off += __off;
 return *this;
      }





      fpos&
      operator-=(streamoff __off)
      {
 _M_off -= __off;
 return *this;
      }







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };






  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;



  typedef fpos<mbstate_t> u8streampos;




  typedef fpos<mbstate_t> u16streampos;

  typedef fpos<mbstate_t> u32streampos;



}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 78 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 3
  class ios_base;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
     typename _Alloc = allocator<_CharT> >
    class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_stringstream;

}

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;



  typedef basic_ios<char> ios;


  typedef basic_streambuf<char> streambuf;


  typedef basic_istream<char> istream;


  typedef basic_ostream<char> ostream;


  typedef basic_iostream<char> iostream;


  typedef basic_stringbuf<char> stringbuf;


  typedef basic_istringstream<char> istringstream;


  typedef basic_ostringstream<char> ostringstream;


  typedef basic_stringstream<char> stringstream;


  typedef basic_filebuf<char> filebuf;


  typedef basic_ifstream<char> ifstream;


  typedef basic_ofstream<char> ofstream;


  typedef basic_fstream<char> fstream;



  typedef basic_ios<wchar_t> wios;


  typedef basic_streambuf<wchar_t> wstreambuf;


  typedef basic_istream<wchar_t> wistream;


  typedef basic_ostream<wchar_t> wostream;


  typedef basic_iostream<wchar_t> wiostream;


  typedef basic_stringbuf<wchar_t> wstringbuf;


  typedef basic_istringstream<wchar_t> wistringstream;


  typedef basic_ostringstream<wchar_t> wostringstream;


  typedef basic_stringstream<wchar_t> wstringstream;


  typedef basic_filebuf<wchar_t> wfilebuf;


  typedef basic_ifstream<wchar_t> wifstream;


  typedef basic_ofstream<wchar_t> wofstream;


  typedef basic_fstream<wchar_t> wfstream;



  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Allocator = allocator<_CharT>>
    class basic_syncbuf;
  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Allocator = allocator<_CharT>>
    class basic_osyncstream;

  using syncbuf = basic_syncbuf<char>;
  using osyncstream = basic_osyncstream<char>;


  using wsyncbuf = basic_syncbuf<wchar_t>;
  using wosyncstream = basic_osyncstream<wchar_t>;
# 258 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iosfwd" 3
}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception.h" 3
extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  };



}

}
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 2 3

extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 3
  class bad_exception : public exception
  {
  public:
    bad_exception() noexcept { }



    virtual ~bad_exception() noexcept;


    virtual const char*
    what() const noexcept;
  };


  typedef void (*terminate_handler) ();


  terminate_handler set_terminate(terminate_handler) noexcept;



  terminate_handler get_terminate() noexcept;




  void terminate() noexcept __attribute__ ((__noreturn__,__cold__));



  typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) ();





  __attribute__ ((__deprecated__))
  unexpected_handler set_unexpected(unexpected_handler) noexcept;







  __attribute__ ((__deprecated__))
  unexpected_handler get_unexpected() noexcept;







  __attribute__ ((__deprecated__))
  void unexpected() __attribute__ ((__noreturn__,__cold__));
# 126 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 3
  __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead")))
  bool uncaught_exception() noexcept __attribute__ ((__pure__));






  int uncaught_exceptions() noexcept __attribute__ ((__pure__));



}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 160 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 3
  void __verbose_terminate_handler();


}

}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_defines.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cxxabi_init_exception.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cxxabi_init_exception.h" 3
#pragma GCC visibility push(default)

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_header_macro.h" 1 3
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_wchar_t.h" 1 3
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_nullptr_t.h" 1 3
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_max_align_t.h" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_max_align_t.h" 3
typedef struct {
  long long __clang_max_align_nonce1
      __attribute__((__aligned__(__alignof__(long long))));
  long double __clang_max_align_nonce2
      __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
# 124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_offsetof.h" 1 3
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cxxabi_init_exception.h" 2 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cxxabi_init_exception.h" 3
namespace std
{
  class type_info;
}

namespace __cxxabiv1
{
  struct __cxa_refcounted_exception;

  extern "C"
    {

      void*
      __cxa_allocate_exception(size_t) noexcept;

      void
      __cxa_free_exception(void*) noexcept;


      __cxa_refcounted_exception*
      __cxa_init_primary_exception(void *__object, std::type_info *__tinfo,
                void ( *__dest) (void *))
 noexcept;

    }
}



#pragma GCC visibility pop
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hash_bytes.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);


}
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 3
namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const noexcept
    { return __name[0] == '*' ? __name + 1 : __name; }



    bool before(const type_info& __arg) const noexcept;


    bool operator==(const type_info& __arg) const noexcept;







    size_t hash_code() const noexcept
    {

      return _Hash_bytes(name(), __builtin_strlen(name()),
    static_cast<size_t>(0xc70f6907UL));



    }



    virtual bool __is_pointer_p() const;


    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
       unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
        void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:


    type_info& operator=(const type_info&) = delete;
    type_info(const type_info&) = delete;
# 168 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 3
  };


  inline bool
  type_info::before(const type_info& __arg) const noexcept
  {




    if (__name[0] != '*' || __arg.__name[0] != '*')
      return __builtin_strcmp (__name, __arg.__name) < 0;
# 188 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 3
    return __name < __arg.__name;
  }






                       inline bool
  type_info::operator==(const type_info& __arg) const noexcept
  {
    if (std::__is_constant_evaluated())
      return this == &__arg;

    if (__name == __arg.__name)
      return true;






    return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0;



  }
# 224 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/typeinfo" 3
  class bad_cast : public exception
  {
  public:
    bad_cast() noexcept { }



    virtual ~bad_cast() noexcept;


    virtual const char* what() const noexcept;
  };





  class bad_typeid : public exception
  {
  public:
    bad_typeid () noexcept { }



    virtual ~bad_typeid() noexcept;


    virtual const char* what() const noexcept;
  };
}

}

#pragma GCC visibility pop
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/new" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/new" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/new" 2 3

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

#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;

}
# 137 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/new" 3
[[__nodiscard__]] void* operator new(std::size_t)

  __attribute__((__externally_visible__, __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t)

  __attribute__((__externally_visible__, __malloc__));
void operator delete(void*) noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*) noexcept
  __attribute__((__externally_visible__));

void operator delete(void*, std::size_t)
                    noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*, std::size_t)
                    noexcept
  __attribute__((__externally_visible__));

[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
void operator delete(void*, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__));

[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t)

  __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__));
[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__));
void operator delete(void*, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete(void*, std::align_val_t, const std::nothrow_t&)

  noexcept __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t)

  __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
                    noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __alloc_align__ (2), __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__));
# 205 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/new" 3
[[__nodiscard__]] inline
void* operator new(std::size_t, void* __p)
                    noexcept
{ return __p; }
[[__nodiscard__]] inline
void* operator new[](std::size_t, void* __p)
                    noexcept
{ return __p; }




inline void operator delete (void*, void*)
                    noexcept
{ }
inline void operator delete[](void*, void*)
                    noexcept
{ }

}

namespace std
{


  template<typename _Tp>
    [[nodiscard]] constexpr _Tp*
    launder(_Tp* __p) noexcept
    {
      if constexpr (__is_same(const volatile _Tp, const volatile void))
 static_assert(!__is_same(const volatile _Tp, const volatile void),
        "std::launder argument must not be a void pointer");

      else if constexpr (__is_function(_Tp))
 static_assert(!__is_function(_Tp),
        "std::launder argument must not be a function pointer");

      else
 return __builtin_launder(__p);
      return nullptr;
    }



  inline constexpr size_t hardware_destructive_interference_size = 64;
  inline constexpr size_t hardware_constructive_interference_size = 64;






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

  inline constexpr destroying_delete_t destroying_delete{};

}

#pragma GCC visibility pop
#pragma GCC diagnostic pop
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 1 3
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 2 3

extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp>
    class reference_wrapper;
# 91 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp, _Tp __v>
    struct integral_constant
    {
      static constexpr _Tp value = __v;
      using value_type = _Tp;
      using type = integral_constant<_Tp, __v>;
      constexpr operator value_type() const noexcept { return value; }


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

    };
# 111 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<bool __v>
    using __bool_constant = integral_constant<bool, __v>;



  using true_type = __bool_constant<true>;


  using false_type = __bool_constant<false>;




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






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


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


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

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

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


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


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

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

  namespace __detail
  {

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


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

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

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

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




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

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

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





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

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

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

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

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


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

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

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

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

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




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

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

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





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


  template<typename>
    struct __is_array_unknown_bounds;




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

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


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





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

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

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

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

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


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

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

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

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

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




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


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


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

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

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

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

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

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

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

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

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

  template<>
    struct __is_integral_helper<unsigned long long>
    : public true_type { };
# 465 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 { };
# 525 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_floating_point
    : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
    { };



  template<typename _Tp>
    struct is_array
    : public __bool_constant<__is_array(_Tp)>
    { };
# 552 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_pointer
    : public __bool_constant<__is_pointer(_Tp)>
    { };
# 579 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename>
    struct is_lvalue_reference
    : public false_type { };

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


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

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



  template<typename _Tp>
    struct is_member_object_pointer
    : public __bool_constant<__is_member_object_pointer(_Tp)>
    { };
# 620 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_member_function_pointer
    : public __bool_constant<__is_member_function_pointer(_Tp)>
    { };
# 641 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_enum
    : public __bool_constant<__is_enum(_Tp)>
    { };


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


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



  template<typename _Tp>
    struct is_function
    : public __bool_constant<__is_function(_Tp)>
    { };
# 680 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_null_pointer
    : public false_type { };

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

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

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

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



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






  template<typename _Tp>
    struct is_reference
    : public __bool_constant<__is_reference(_Tp)>
    { };
# 734 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_arithmetic
    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
    { };


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



  template<typename _Tp>
    struct is_object
    : public __bool_constant<__is_object(_Tp)>
    { };
# 760 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename>
    struct is_member_pointer;


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


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



  template<typename _Tp>
    struct is_member_pointer
    : public __bool_constant<__is_member_pointer(_Tp)>
    { };
# 798 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename, typename>
    struct is_same;


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


  __extension__
  template<typename _Tp>
    using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
   signed char, signed short, signed int, signed long,
   signed long long
# 823 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
   >;


  __extension__
  template<typename _Tp>
    using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
   unsigned char, unsigned short, unsigned int, unsigned long,
   unsigned long long
# 843 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
   >;


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


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






  template<typename _Tp>
    struct is_const
    : public __bool_constant<__is_const(_Tp)>
    { };
# 874 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_volatile
    : public __bool_constant<__is_volatile(_Tp)>
    { };
# 895 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct

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


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


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






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





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


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


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




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



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


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

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



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


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


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

  template<typename _Tp>
    _Tp
    __declval(long);


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

  template<typename>
    struct remove_all_extents;


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

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

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

  template<typename _Tp>
    struct __is_array_unknown_bounds<_Tp[]>
    : public true_type
    { };
# 1047 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  struct __do_is_destructible_impl
  {
    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
      static true_type __test(int);

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

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

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

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

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

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



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







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

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

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

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

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

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

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



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


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



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


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



  template<typename _Tp>
    using __add_lval_ref_t = __add_lvalue_reference(_Tp);
# 1191 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_copy_constructible
    : public __is_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
 "template argument must be a complete class or an unbounded array");
    };



  template<typename _Tp>
    using __add_rval_ref_t = __add_rvalue_reference(_Tp);
# 1218 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_move_constructible
    : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
 "template argument must be a complete class or an unbounded array");
    };


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



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


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


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


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


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



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


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


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


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



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


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


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


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



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


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


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

  template<typename _Tp>
    struct __is_implicitly_default_constructible
    : __bool_constant<__is_implicitly_default_constructible_v<_Tp>>
    { };
# 1402 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_trivially_copy_constructible
    : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
 "template argument must be a complete class or an unbounded array");
    };


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


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



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


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


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


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



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





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




  template<typename _Tp>
    struct rank
    : public integral_constant<std::size_t, __array_rank(_Tp)> { };
# 1507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename, unsigned _Uint = 0>
    struct extent
    : public integral_constant<size_t, 0> { };

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

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

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

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






  template<typename _Tp, typename _Up>
    struct is_same
    : public __bool_constant<__is_same(_Tp, _Up)>
    { };
# 1549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Base, typename _Derived>
    struct is_base_of
    : public __bool_constant<__is_base_of(_Base, _Derived)>
    { };
# 1564 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _From, typename _To>
    struct is_convertible
    : public __bool_constant<__is_convertible(_From, _To)>
    { };
# 1607 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _ToElementType, typename _FromElementType>
    using __is_array_convertible
      = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;





  template<typename _From, typename _To>
    inline constexpr bool is_nothrow_convertible_v
      = __is_nothrow_convertible(_From, _To);


  template<typename _From, typename _To>
    struct is_nothrow_convertible
    : public bool_constant<is_nothrow_convertible_v<_From, _To>>
    { };
# 1667 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++14-extensions"
  template<typename _Tp, typename... _Args>
    struct __is_nothrow_new_constructible_impl
    : __bool_constant<
 noexcept(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))
      >
    { };

  template<typename _Tp, typename... _Args>
    inline constexpr bool __is_nothrow_new_constructible
      = __and_<is_constructible<_Tp, _Args...>,
        __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value;
#pragma GCC diagnostic pop




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

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


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

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



  template<typename _Tp>
    struct remove_cv
    { using type = __remove_cv(_Tp); };
# 1726 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct add_const
    { using type = _Tp const; };


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


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



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


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


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


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


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


  template<typename _Tp>
    using add_cv_t = typename add_cv<_Tp>::type;
# 1774 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct remove_reference
    { using type = _Tp; };

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

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



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


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



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


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


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







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

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

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

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

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

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

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


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

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

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

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

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

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

  template<>
    struct __make_unsigned<long long>
    { using __type = unsigned long long; };
# 1901 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = __is_enum(_Tp)>
    class __make_unsigned_selector;

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

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

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

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

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

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

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


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

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

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

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





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


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


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

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






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


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




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

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

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

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

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

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

  template<>
    struct __make_signed<unsigned long long>
    { using __type = signed long long; };
# 2061 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = __is_enum(_Tp)>
    class __make_signed_selector;

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

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


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

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





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


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


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

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






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


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



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


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






  template<typename _Tp>
    struct remove_extent
    { using type = __remove_extent(_Tp); };
# 2169 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct remove_all_extents
    { using type = __remove_all_extents(_Tp); };
# 2188 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    using remove_extent_t = typename remove_extent<_Tp>::type;


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






  template<typename _Tp>
    struct remove_pointer
    { using type = __remove_pointer(_Tp); };
# 2220 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct add_pointer
    { using type = __add_pointer(_Tp); };
# 2248 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    using remove_pointer_t = typename remove_pointer<_Tp>::type;


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





  struct __attribute__((__aligned__)) __aligned_storage_max_align_t
  { };

  constexpr size_t
  __aligned_storage_default_alignment([[__maybe_unused__]] size_t __len)
  {
# 2279 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
    return alignof(__aligned_storage_max_align_t);

  }
# 2315 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<size_t _Len,
    size_t _Align = __aligned_storage_default_alignment(_Len)>
    struct

    aligned_storage
    {
      struct type
      {
 alignas(_Align) unsigned char __data[_Len];
      };
    };

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

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

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 2360 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

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

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




  template<typename _Tp>
    struct decay
    { using type = __decay(_Tp); };
# 2425 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct __strip_reference_wrapper
    {
      using __type = _Tp;
    };

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


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

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





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


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




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


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


  template<typename... _Tp>
    struct common_type;
# 2481 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct __success_type
    { using type = _Tp; };

  struct __failure_type
  { };

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



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




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


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

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


  template<>
    struct common_type<>
    { };


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


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


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

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


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


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

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

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


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




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


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

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

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



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


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






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


  template<typename _Signature>
    struct result_of;




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


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


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

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

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


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

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

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


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

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

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


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

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

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

  template<typename _MemPtr, typename _Arg>
    struct __result_of_memobj;

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

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

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






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

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

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

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

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


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

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

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


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


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


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


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

  template<size_t _Len,
    size_t _Align = __aligned_storage_default_alignment(_Len)>
    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;
#pragma GCC diagnostic pop


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


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


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


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


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


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




  template<typename...> using void_t = void;
# 2868 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Def, template<typename...> class _Op, typename... _Args>
    struct __detected_or
    {
      using type = _Def;
      using __is_detected = false_type;
    };


  template<typename _Def, template<typename...> class _Op, typename... _Args>
    requires requires { typename _Op<_Args...>; }
    struct __detected_or<_Def, _Op, _Args...>
    {
      using type = _Op<_Args...>;
      using __is_detected = true_type;
    };
# 2908 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Default, template<typename...> class _Op,
    typename... _Args>
    using __detected_or_t
      = typename __detected_or<_Default, _Op, _Args...>::type;
# 2927 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template <typename _Tp>
    struct __is_swappable;

  template <typename _Tp>
    struct __is_nothrow_swappable;

  template<typename>
    struct __is_tuple_like_impl : false_type
    { };


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


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

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


  namespace __swappable_details {
    using std::swap;

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

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

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

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

  }

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

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

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

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






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


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



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


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



  namespace __swappable_with_details {
    using std::swap;

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

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

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

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

  }

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


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

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


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



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


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



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


  template<typename _Tp, typename _Up>
    inline constexpr bool is_nothrow_swappable_with_v =
      is_nothrow_swappable_with<_Tp, _Up>::value;
# 3149 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Result, typename _Ret,
    bool = is_void<_Ret>::value, typename = void>
    struct __is_invocable_impl
    : false_type
    {
      using __nothrow_conv = false_type;
    };


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

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

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

      using _Res_t = typename _Result::type;



      static _Res_t _S_get() noexcept;


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


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

        bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t)



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

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

    public:

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


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

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

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

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

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

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

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

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

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


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

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




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


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


  template<typename _Fn, typename... _ArgTypes>
    struct is_invocable



    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type

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


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


  template<typename _Fn, typename... _ArgTypes>
    struct is_nothrow_invocable



    : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
      __call_is_nothrow_<_Fn, _ArgTypes...>>::type

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





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



  template<typename _Ret, typename _Fn, typename... _ArgTypes>
    struct is_nothrow_invocable_r
    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
 "_Fn must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
 "_Ret must be a complete class or an unbounded array");
    };
# 3385 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_void_v = is_void<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;


template <typename _Tp>
  inline constexpr bool is_array_v = __is_array(_Tp);
# 3407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_pointer_v = __is_pointer(_Tp);
# 3422 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_lvalue_reference_v = false;
template <typename _Tp>
  inline constexpr bool is_lvalue_reference_v<_Tp&> = true;
template <typename _Tp>
  inline constexpr bool is_rvalue_reference_v = false;
template <typename _Tp>
  inline constexpr bool is_rvalue_reference_v<_Tp&&> = true;


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







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






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



template <typename _Tp>
  inline constexpr bool is_reference_v = __is_reference(_Tp);
# 3471 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;


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





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


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






template <typename _Tp>
  inline constexpr bool is_const_v = __is_const(_Tp);
# 3508 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_function_v = __is_function(_Tp);
# 3520 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_volatile_v = __is_volatile(_Tp);







template <typename _Tp>

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

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

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

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

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

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

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


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

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






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

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

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

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

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



template <typename _Tp>
  inline constexpr size_t rank_v = __array_rank(_Tp);
# 3673 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
template <typename _Tp, unsigned _Idx = 0>
  inline constexpr size_t extent_v = 0;
template <typename _Tp, size_t _Size>
  inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size;
template <typename _Tp, unsigned _Idx, size_t _Size>
  inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>;
template <typename _Tp>
  inline constexpr size_t extent_v<_Tp[], 0> = 0;
template <typename _Tp, unsigned _Idx>
  inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>;


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






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





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




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






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



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






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






  template<typename _Tp>
    inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>);
# 3765 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct remove_cvref
    { using type = __remove_cvref(_Tp); };
# 3782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    using remove_cvref_t = typename remove_cvref<_Tp>::type;
# 3792 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct type_identity { using type = _Tp; };

  template<typename _Tp>
    using type_identity_t = typename type_identity<_Tp>::type;
# 3805 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct unwrap_reference { using type = _Tp; };

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

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






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

  template<typename _Tp>
    using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
# 3832 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    inline constexpr bool is_bounded_array_v = __is_bounded_array(_Tp);
# 3846 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    inline constexpr bool is_unbounded_array_v = __is_unbounded_array(_Tp);
# 3858 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Tp>
    struct is_bounded_array
    : public bool_constant<is_bounded_array_v<_Tp>>
    { };



  template<typename _Tp>
    struct is_unbounded_array
    : public bool_constant<is_unbounded_array_v<_Tp>>
    { };





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



  template<typename _Tp, typename _Up>
    constexpr bool is_layout_compatible_v
      = __is_layout_compatible(_Tp, _Up);
# 3902 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  template<typename _Base, typename _Derived>
    struct is_pointer_interconvertible_base_of
    : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)>
    { };



  template<typename _Base, typename _Derived>
    constexpr bool is_pointer_interconvertible_base_of_v
      = __is_pointer_interconvertible_base_of(_Base, _Derived);
# 4005 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/type_traits" 3
  constexpr inline bool
  is_constant_evaluated() noexcept
  {



    return __builtin_is_constant_evaluated();

  }




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

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

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


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


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


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


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


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


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


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


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


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


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

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

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

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


  template<typename... _Tp>
    struct common_reference;

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


  template<>
    struct common_reference<>
    { };


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


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


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


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

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

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

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


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


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


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


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


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


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







}
}
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 2 3


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







  template<typename _Tp>
    __attribute__((__always_inline__))
    inline constexpr _Tp*
    __addressof(_Tp& __r) noexcept
    { return __builtin_addressof(__r); }
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__,__gnu__::__always_inline__]]
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__,__gnu__::__always_inline__]]
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value,
   "std::forward must not be used to convert an rvalue to an lvalue");
      return static_cast<_Tp&&>(__t);
    }
# 135 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__,__gnu__::__always_inline__]]
    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 { };
# 156 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__,__gnu__::__always_inline__]]
    constexpr
    __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>
    move_if_noexcept(_Tp& __x) noexcept
    { return std::move(__x); }
# 173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__,__gnu__::__always_inline__]]
    inline constexpr _Tp*
    addressof(_Tp& __r) noexcept
    { return std::__addressof(__r); }



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


  template <typename _Tp, typename _Up = _Tp>
    constexpr
    inline _Tp
    __exchange(_Tp& __obj, _Up&& __new_val)
    {
      _Tp __old_val = std::move(__obj);
      __obj = std::forward<_Up>(__new_val);
      return __old_val;
    }
# 217 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/move.h" 3
  template<typename _Tp>
    constexpr
    inline

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



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

    {




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




  template<typename _Tp, size_t _Nm>
    constexpr
    inline

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



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



}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 2 3








extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
  class type_info;






  namespace __exception_ptr
  {
    class exception_ptr;
  }

  using __exception_ptr::exception_ptr;
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
  exception_ptr current_exception() noexcept;

  template<typename _Ex>
  exception_ptr make_exception_ptr(_Ex) noexcept;


  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));

  namespace __exception_ptr
  {
    using std::rethrow_exception;
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
    class exception_ptr
    {
      void* _M_exception_object;

      explicit exception_ptr(void* __e) noexcept;

      void _M_addref() noexcept;
      void _M_release() noexcept;

      void *_M_get() const noexcept __attribute__ ((__pure__));

      friend exception_ptr std::current_exception() noexcept;
      friend void std::rethrow_exception(exception_ptr);
      template<typename _Ex>
      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;

    public:
      exception_ptr() noexcept;

      exception_ptr(const exception_ptr&) noexcept;


      exception_ptr(nullptr_t) noexcept
      : _M_exception_object(nullptr)
      { }

      exception_ptr(exception_ptr&& __o) noexcept
      : _M_exception_object(__o._M_exception_object)
      { __o._M_exception_object = nullptr; }
# 135 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 161 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
      explicit operator bool() const noexcept
      { return _M_exception_object; }




      friend bool
      operator==(const exception_ptr&, const exception_ptr&) noexcept = default;
# 181 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
      const class std::type_info*
      __cxa_exception_type() const noexcept
 __attribute__ ((__pure__));
    };


    inline
    exception_ptr::exception_ptr() noexcept
    : _M_exception_object(0)
    { }


    inline
    exception_ptr::exception_ptr(const exception_ptr& __other)
    noexcept
    : _M_exception_object(__other._M_exception_object)
    {
      if (_M_exception_object)
 _M_addref();
    }


    inline
    exception_ptr::~exception_ptr() noexcept
    {
      if (_M_exception_object)
 _M_release();
    }


    inline exception_ptr&
    exception_ptr::operator=(const exception_ptr& __other) noexcept
    {
      exception_ptr(__other).swap(*this);
      return *this;
    }


    inline void
    exception_ptr::swap(exception_ptr &__other) noexcept
    {
      void *__tmp = _M_exception_object;
      _M_exception_object = __other._M_exception_object;
      __other._M_exception_object = __tmp;
    }


    inline void
    swap(exception_ptr& __lhs, exception_ptr& __rhs)
    { __lhs.swap(__rhs); }


    template<typename _Ex>

      inline void
      __dest_thunk(void* __x)
      { static_cast<_Ex*>(__x)->~_Ex(); }


  }

  using __exception_ptr::swap;



  template<typename _Ex>
    exception_ptr
    make_exception_ptr(_Ex __ex) noexcept
    {

      using _Ex2 = typename decay<_Ex>::type;
      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
      (void) __cxxabiv1::__cxa_init_primary_exception(
   __e, const_cast<std::type_info*>(&typeid(_Ex)),
   __exception_ptr::__dest_thunk<_Ex2>);
      try
 {
   ::new (__e) _Ex2(__ex);
   return exception_ptr(__e);
 }
      catch(...)
 {
   __cxxabiv1::__cxa_free_exception(__e);
   return current_exception();
 }
# 276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
    }
# 290 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/exception_ptr.h" 3
}

}
# 169 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 3
extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 3
  class nested_exception
  {
    exception_ptr _M_ptr;

  public:

    nested_exception() noexcept : _M_ptr(current_exception()) { }

    nested_exception(const nested_exception&) noexcept = default;

    nested_exception& operator=(const nested_exception&) noexcept = default;

    virtual ~nested_exception() noexcept;


    [[noreturn]]
    void
    rethrow_nested() const
    {
      if (_M_ptr)
 rethrow_exception(_M_ptr);
      std::terminate();
    }


    exception_ptr
    nested_ptr() const noexcept
    { return _M_ptr; }
  };



  template<typename _Except>
    struct _Nested_exception : public _Except, public nested_exception
    {
      explicit _Nested_exception(const _Except& __ex)
      : _Except(__ex)
      { }

      explicit _Nested_exception(_Except&& __ex)
      : _Except(static_cast<_Except&&>(__ex))
      { }
    };
# 145 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 3
  template<typename _Tp>
    [[noreturn]]
    inline void
    throw_with_nested(_Tp&& __t)
    {
      using _Up = typename decay<_Tp>::type;
      using _CopyConstructible
 = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
      static_assert(_CopyConstructible::value,
   "throw_with_nested argument must be CopyConstructible");


      if constexpr (is_class_v<_Up>)
 if constexpr (!is_final_v<_Up>)
   if constexpr (!is_base_of_v<nested_exception, _Up>)
     throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
      throw std::forward<_Tp>(__t);





    }
# 203 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 3
  template<typename _Ex>



    inline void
    rethrow_if_nested(const _Ex& __ex)
    {
      const _Ex* __ptr = __builtin_addressof(__ex);
# 223 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/nested_exception.h" 3
      if constexpr (!is_polymorphic_v<_Ex>)
 return;
      else if constexpr (is_base_of_v<nested_exception, _Ex>
    && !is_convertible_v<_Ex*, nested_exception*>)
 return;




      else if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
 __ne_ptr->rethrow_nested();

    }


}

}
# 170 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/exception" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/concepts" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/concepts" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/concepts" 2 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/concepts" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




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


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

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


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


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


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


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



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

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

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

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

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

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

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

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

  }


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


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


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


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


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


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



  namespace ranges
  {

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

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

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

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

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


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

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

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



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

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

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




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

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



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

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

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

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


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

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

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




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


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


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


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


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


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


}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 2 3

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"

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


  namespace __cmp_cat
  {
    using type = signed char;

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

    enum class _Ncmp : type { _Unordered = 2 };

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

  class partial_ordering
  {

    __cmp_cat::type _M_value;

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

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

    friend class weak_ordering;
    friend class strong_ordering;

  public:

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

  class weak_ordering
  {
    __cmp_cat::type _M_value;

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

    friend class strong_ordering;

  public:

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

  class strong_ordering
  {
    __cmp_cat::type _M_value;

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

  public:

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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



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

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

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

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

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

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

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

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

 if constexpr (__cats & 1)
   return;


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


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

 else
   return strong_ordering::equivalent;
      }
  }


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



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

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

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

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

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

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



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


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

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

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






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

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


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


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

  namespace __detail
  {




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





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

    using is_transparent = void;
  };



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


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

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

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

    void strong_order() = delete;

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

    void weak_order() = delete;

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

    void partial_order() = delete;

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

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

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

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

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

      friend class _Weak_order;
      friend class _Strong_fallback;


      enum class _Fp_fmt
      {
 _Binary16, _Binary32, _Binary64, _Binary128,
 _X86_80bit,
 _M68k_80bit,
 _Dbldbl,
 _Bfloat16,
      };
# 705 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
      template<typename _Tp>
 static consteval _Fp_fmt
 _S_fp_fmt() noexcept
 {

   using enum _Fp_fmt;
# 725 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
   if constexpr (__is_same(_Tp, long double))
     return (-16381) == -16381 ? _X86_80bit : _M68k_80bit;
# 737 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
   constexpr int __width = sizeof(_Tp) * 8;

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


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


      template<typename _Tp>
 struct _Int
 {

   uint64_t _M_lo;
   _Tp _M_hi;





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

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

   constexpr bool operator==(const _Int&) const = default;
# 787 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
   constexpr _Int&
   operator^=(const _Int& __rhs) noexcept
   {
     _M_hi ^= __rhs._M_hi;
     _M_lo ^= __rhs._M_lo;
     return *this;
   }

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

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

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


   return __t ^ (__sign >> 1);
 }


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


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

       using enum _Fp_fmt;

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

    return __builtin_bit_cast(__int128, __val);



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

      template<typename _Tp>
 static constexpr strong_ordering
 _S_fp_cmp(_Tp __x, _Tp __y) noexcept
 {
# 896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
   auto __ix = _S_fp_bits(__x);
   auto __iy = _S_fp_bits(__y);

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


   using enum _Fp_fmt;

   constexpr auto __fmt = _S_fp_fmt<_Tp>();

   if constexpr (__fmt == _Dbldbl)
     {


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


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



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


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


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



    constexpr uint16_t __maxexp = 0x7fff;
    if ((__ix._M_hi & __maxexp) == __maxexp)
      __ix._M_lo |= 1ull << 63;
    if ((__iy._M_hi & __maxexp) == __maxexp)
      __iy._M_lo |= 1ull << 63;
  }
       else
  {
# 963 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/compare" 3
  }
       return _S_compl(__ix) <=> _S_compl(__iy);
     }
 }

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

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

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

      friend class _Partial_order;
      friend class _Weak_fallback;

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

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

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

      friend class _Partial_fallback;

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

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

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

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

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

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



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

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

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



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

    inline constexpr __compare::_Weak_order weak_order{};

    inline constexpr __compare::_Partial_order partial_order{};

    inline constexpr __compare::_Strong_fallback
      compare_strong_order_fallback{};

    inline constexpr __compare::_Weak_fallback
      compare_weak_order_fallback{};

    inline constexpr __compare::_Partial_fallback
      compare_partial_order_fallback{};
  }


  namespace __detail
  {

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

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


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


}

#pragma GCC diagnostic pop
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 1 3
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ptr_traits.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ptr_traits.h" 3
namespace __gnu_debug { struct _Safe_iterator_base; }


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




  class __undefined;



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

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



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

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


  template<typename _Ptr, typename = void>
    struct __ptr_traits_elem : __get_first_arg<_Ptr>
    { };



  template<typename _Ptr> requires requires { typename _Ptr::element_type; }
    struct __ptr_traits_elem<_Ptr, void>
    { using type = typename _Ptr::element_type; };






  template<typename _Ptr>
    using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type;




  template<typename _Ptr, typename _Elt, bool = is_void<_Elt>::value>
    struct __ptr_traits_ptr_to
    {
      using pointer = _Ptr;
      using element_type = _Elt;







      static pointer
      pointer_to(element_type& __r)

      requires requires {
 { pointer::pointer_to(__r) } -> convertible_to<pointer>;
      }

      { return pointer::pointer_to(__r); }
    };


  template<typename _Ptr, typename _Elt>
    struct __ptr_traits_ptr_to<_Ptr, _Elt, true>
    { };


  template<typename _Tp>
    struct __ptr_traits_ptr_to<_Tp*, _Tp, false>
    {
      using pointer = _Tp*;
      using element_type = _Tp;






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

  template<typename _Ptr, typename _Elt>
    struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt>
    {
    private:
      template<typename _Tp>
 using __diff_t = typename _Tp::difference_type;

      template<typename _Tp, typename _Up>
 using __rebind = __type_identity<typename _Tp::template rebind<_Up>>;

    public:

      using pointer = _Ptr;


      using element_type = _Elt;


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


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



  template<typename _Ptr>
    struct __ptr_traits_impl<_Ptr, __undefined>
    { };







  template<typename _Ptr>
    struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>>
    { };







  template<typename _Tp>
    struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp>
    {

      typedef _Tp* pointer;

      typedef _Tp element_type;

      typedef ptrdiff_t difference_type;

      template<typename _Up> using rebind = _Up*;
    };


  template<typename _Ptr, typename _Tp>
    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
# 229 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ptr_traits.h" 3
  template<typename _Tp>
    [[__gnu__::__always_inline__]]
    constexpr _Tp*
    to_address(_Tp* __ptr) noexcept
    {
      static_assert(!is_function_v<_Tp>, "std::to_address argument "
      "must not be a function pointer");
      return __ptr;
    }
# 246 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ptr_traits.h" 3
  template<typename _Ptr>
    constexpr auto
    to_address(const _Ptr& __ptr) noexcept
    {
      if constexpr (requires { pointer_traits<_Ptr>::to_address(__ptr); })
 return pointer_traits<_Ptr>::to_address(__ptr);
      else if constexpr (is_base_of_v<__gnu_debug::_Safe_iterator_base, _Ptr>)
 return std::to_address(__ptr.base().operator->());
      else
 return std::to_address(__ptr.operator->());
    }



  template<typename _Ptr>
    [[__gnu__::__always_inline__]]
    constexpr auto
    __to_address(const _Ptr& __ptr) noexcept
    { return std::to_address(__ptr); }




}
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_cmp.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_cmp.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __is_transparent;





  struct identity
  {
    template<typename _Tp>
      [[nodiscard]]
      constexpr _Tp&&
      operator()(_Tp&& __t) const noexcept
      { return std::forward<_Tp>(__t); }

    using is_transparent = __is_transparent;
  };


namespace ranges
{
  namespace __detail
  {



    template<typename _Tp, typename _Up>
      concept __less_builtin_ptr_cmp
 = requires (_Tp&& __t, _Up&& __u) { { __t < __u } -> same_as<bool>; }
   && convertible_to<_Tp, const volatile void*>
   && convertible_to<_Up, const volatile void*>
   && (! requires(_Tp&& __t, _Up&& __u)
       { operator<(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }
       && ! requires(_Tp&& __t, _Up&& __u)
       { std::forward<_Tp>(__t).operator<(std::forward<_Up>(__u)); });
  }







  struct equal_to
  {
    template<typename _Tp, typename _Up>
      requires equality_comparable_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() == std::declval<_Up>()))
      { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

    using is_transparent = __is_transparent;
  };


  struct not_equal_to
  {
    template<typename _Tp, typename _Up>
      requires equality_comparable_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() == std::declval<_Up>()))
      { return !equal_to{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

    using is_transparent = __is_transparent;
  };


  struct less
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
      {
 if constexpr (__detail::__less_builtin_ptr_cmp<_Tp, _Up>)
   {
     if (std::__is_constant_evaluated())
       return __t < __u;

     auto __x = reinterpret_cast<long unsigned int>(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)));
     auto __y = reinterpret_cast<long unsigned int>(
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
     return __x < __y;
   }
 else
   return std::forward<_Tp>(__t) < std::forward<_Up>(__u);
      }

    using is_transparent = __is_transparent;
  };


  struct greater
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
      { return less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

    using is_transparent = __is_transparent;
  };


  struct greater_equal
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
      { return !less{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

    using is_transparent = __is_transparent;
  };


  struct less_equal
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
      { return !less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

    using is_transparent = __is_transparent;
  };

}


}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 2 3

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 3
  struct default_sentinel_t { };


  inline constexpr default_sentinel_t default_sentinel{};


  struct input_iterator_tag;
  struct output_iterator_tag;
  struct forward_iterator_tag;
  struct bidirectional_iterator_tag;
  struct random_access_iterator_tag;
  struct contiguous_iterator_tag;

  template<typename _Iterator>
    struct iterator_traits;

  template<typename _Tp> requires is_object_v<_Tp>
    struct iterator_traits<_Tp*>;

  template<typename _Iterator, typename>
    struct __iterator_traits;

  namespace __detail
  {
    template<typename _Tp>
      using __with_ref = _Tp&;

    template<typename _Tp>
      concept __can_reference = requires { typename __with_ref<_Tp>; };

    template<typename _Tp>
      concept __dereferenceable = requires(_Tp& __t)
 {
   { *__t } -> __can_reference;
 };
  }

  template<__detail::__dereferenceable _Tp>
    using iter_reference_t = decltype(*std::declval<_Tp&>());

  namespace ranges
  {


    namespace __imove
    {
      void iter_move() = delete;



      template<typename _Tp>
 concept __adl_imove
   = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>)
       && requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); };

      struct _IterMove
      {
      private:


 template<typename _Tp>
   using __iter_ref_t = decltype(*std::declval<_Tp>());

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


 template<typename _Tp>
   requires __adl_imove<_Tp>
   struct __result<_Tp>
   { using type = decltype(iter_move(std::declval<_Tp>())); };


 template<typename _Tp>
   requires (!__adl_imove<_Tp>)
     && is_lvalue_reference_v<__iter_ref_t<_Tp>>
   struct __result<_Tp>
   {




     using type
       = decltype(std::declval<remove_reference_t<__iter_ref_t<_Tp>>>());
   };

 template<typename _Tp>
   static constexpr bool
   _S_noexcept()
   {
     if constexpr (__adl_imove<_Tp>)
       return noexcept(iter_move(std::declval<_Tp>()));
     else
       return noexcept(*std::declval<_Tp>());
   }

      public:

 template<typename _Tp>
   using __type = typename __result<_Tp>::type;

 template<typename _Tp>
   requires __adl_imove<_Tp> || requires { typename __iter_ref_t<_Tp>; }
   [[nodiscard]]
   constexpr __type<_Tp>
   operator()(_Tp&& __e) const
   noexcept(_S_noexcept<_Tp>())
   {
     if constexpr (__adl_imove<_Tp>)
       return iter_move(static_cast<_Tp&&>(__e));
     else if constexpr (is_lvalue_reference_v<__iter_ref_t<_Tp>>)
       return std::move(*static_cast<_Tp&&>(__e));
     else
       return *static_cast<_Tp&&>(__e);
   }
      };
    }


    inline namespace _Cpo {
      inline constexpr __imove::_IterMove iter_move{};
    }
  }


  template<__detail::__dereferenceable _Tp>
    requires __detail::__can_reference<ranges::__imove::_IterMove::__type<_Tp&>>
    using iter_rvalue_reference_t = ranges::__imove::_IterMove::__type<_Tp&>;

  template<typename> struct incrementable_traits { };

  template<typename _Tp> requires is_object_v<_Tp>
    struct incrementable_traits<_Tp*>
    { using difference_type = ptrdiff_t; };

  template<typename _Iter>
    struct incrementable_traits<const _Iter>
    : incrementable_traits<_Iter> { };

  template<typename _Tp> requires requires { typename _Tp::difference_type; }
    struct incrementable_traits<_Tp>
    { using difference_type = typename _Tp::difference_type; };

  template<typename _Tp>
    requires (!requires { typename _Tp::difference_type; }
       && requires(const _Tp& __a, const _Tp& __b)
       { { __a - __b } -> integral; })
    struct incrementable_traits<_Tp>
    {
      using difference_type
 = make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
    };



  template<>
    struct incrementable_traits<__int128>
    { using difference_type = __int128; };

  template<>
    struct incrementable_traits<unsigned __int128>
    { using difference_type = __int128; };


  namespace __detail
  {


    template<typename _Iter>
      concept __primary_traits_iter
 = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);

    template<typename _Iter, typename _Tp>
      struct __iter_traits_impl
      { using type = iterator_traits<_Iter>; };

    template<typename _Iter, typename _Tp>
      requires __primary_traits_iter<_Iter>
      struct __iter_traits_impl<_Iter, _Tp>
      { using type = _Tp; };


    template<typename _Iter, typename _Tp = _Iter>
      using __iter_traits = typename __iter_traits_impl<_Iter, _Tp>::type;

    template<typename _Tp>
      using __iter_diff_t = typename
 __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
  }

  template<typename _Tp>
    using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;

  namespace __detail
  {
    template<typename> struct __cond_value_type { };

    template<typename _Tp> requires is_object_v<_Tp>
      struct __cond_value_type<_Tp>
      { using value_type = remove_cv_t<_Tp>; };

    template<typename _Tp>
      concept __has_member_value_type
 = requires { typename _Tp::value_type; };

    template<typename _Tp>
      concept __has_member_element_type
 = requires { typename _Tp::element_type; };

  }

  template<typename> struct indirectly_readable_traits { };

  template<typename _Tp>
    struct indirectly_readable_traits<_Tp*>
    : __detail::__cond_value_type<_Tp>
    { };

  template<typename _Iter> requires is_array_v<_Iter>
    struct indirectly_readable_traits<_Iter>
    { using value_type = remove_cv_t<remove_extent_t<_Iter>>; };

  template<typename _Iter>
    struct indirectly_readable_traits<const _Iter>
    : indirectly_readable_traits<_Iter>
    { };

  template<__detail::__has_member_value_type _Tp>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::value_type>
    { };

  template<__detail::__has_member_element_type _Tp>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::element_type>
    { };



  template<__detail::__has_member_value_type _Tp>
    requires __detail::__has_member_element_type<_Tp>
    && same_as<remove_cv_t<typename _Tp::element_type>,
        remove_cv_t<typename _Tp::value_type>>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::value_type>
    { };



  template<__detail::__has_member_value_type _Tp>
    requires __detail::__has_member_element_type<_Tp>
    struct indirectly_readable_traits<_Tp>
    { };

  namespace __detail
  {
    template<typename _Tp>
      using __iter_value_t = typename
 __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
  }

  template<typename _Tp>
    using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;

  namespace __detail
  {


    template<typename _Iter>
      concept __cpp17_iterator = requires(_Iter __it)
 {
   { *__it } -> __can_reference;
   { ++__it } -> same_as<_Iter&>;
   { *__it++ } -> __can_reference;
 } && copyable<_Iter>;

    template<typename _Iter>
      concept __cpp17_input_iterator = __cpp17_iterator<_Iter>
 && equality_comparable<_Iter>
 && requires(_Iter __it)
 {
   typename incrementable_traits<_Iter>::difference_type;
   typename indirectly_readable_traits<_Iter>::value_type;
   typename common_reference_t<iter_reference_t<_Iter>&&,
     typename indirectly_readable_traits<_Iter>::value_type&>;
   typename common_reference_t<decltype(*__it++)&&,
     typename indirectly_readable_traits<_Iter>::value_type&>;
   requires signed_integral<
     typename incrementable_traits<_Iter>::difference_type>;
 };



    template<typename _Iter>
      concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter>
 && constructible_from<_Iter>
 && is_reference_v<iter_reference_t<_Iter>>
 && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
     typename indirectly_readable_traits<_Iter>::value_type>
 && requires(_Iter __it)
 {
   { __it++ } -> convertible_to<const _Iter&>;
   { *__it++ } -> same_as<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter>
 && requires(_Iter __it)
 {
   { --__it } -> same_as<_Iter&>;
   { __it-- } -> convertible_to<const _Iter&>;
   { *__it-- } -> same_as<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __cpp17_randacc_iterator = __cpp17_bidi_iterator<_Iter>
 && totally_ordered<_Iter>
 && requires(_Iter __it,
      typename incrementable_traits<_Iter>::difference_type __n)
 {
   { __it += __n } -> same_as<_Iter&>;
   { __it -= __n } -> same_as<_Iter&>;
   { __it + __n } -> same_as<_Iter>;
   { __n + __it } -> same_as<_Iter>;
   { __it - __n } -> same_as<_Iter>;
   { __it - __it } -> same_as<decltype(__n)>;
   { __it[__n] } -> convertible_to<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __iter_with_nested_types = requires {
 typename _Iter::iterator_category;
 typename _Iter::value_type;
 typename _Iter::difference_type;
 typename _Iter::reference;
      };

    template<typename _Iter>
      concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>;

    template<typename _Iter>
      concept __iter_without_category
 = !requires { typename _Iter::iterator_category; };

  }

  template<typename _Iterator>
    requires __detail::__iter_with_nested_types<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __ptr
 { using type = void; };

      template<typename _Iter> requires requires { typename _Iter::pointer; }
 struct __ptr<_Iter>
 { using type = typename _Iter::pointer; };

    public:
      using iterator_category = typename _Iterator::iterator_category;
      using value_type = typename _Iterator::value_type;
      using difference_type = typename _Iterator::difference_type;
      using pointer = typename __ptr<_Iterator>::type;
      using reference = typename _Iterator::reference;
    };

  template<typename _Iterator>
    requires __detail::__iter_without_nested_types<_Iterator>
       && __detail::__cpp17_input_iterator<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __cat
 { using type = input_iterator_tag; };

      template<typename _Iter>
 requires requires { typename _Iter::iterator_category; }
 struct __cat<_Iter>
 { using type = typename _Iter::iterator_category; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_randacc_iterator<_Iter>
 struct __cat<_Iter>
 { using type = random_access_iterator_tag; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_bidi_iterator<_Iter>
 struct __cat<_Iter>
 { using type = bidirectional_iterator_tag; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_fwd_iterator<_Iter>
 struct __cat<_Iter>
 { using type = forward_iterator_tag; };

      template<typename _Iter>
 struct __ptr
 { using type = void; };

      template<typename _Iter> requires requires { typename _Iter::pointer; }
 struct __ptr<_Iter>
 { using type = typename _Iter::pointer; };

      template<typename _Iter>
 requires (!requires { typename _Iter::pointer; }
     && requires(_Iter& __it) { __it.operator->(); })
 struct __ptr<_Iter>
 { using type = decltype(std::declval<_Iter&>().operator->()); };

      template<typename _Iter>
 struct __ref
 { using type = iter_reference_t<_Iter>; };

      template<typename _Iter> requires requires { typename _Iter::reference; }
 struct __ref<_Iter>
 { using type = typename _Iter::reference; };

    public:
      using iterator_category = typename __cat<_Iterator>::type;
      using value_type
 = typename indirectly_readable_traits<_Iterator>::value_type;
      using difference_type
 = typename incrementable_traits<_Iterator>::difference_type;
      using pointer = typename __ptr<_Iterator>::type;
      using reference = typename __ref<_Iterator>::type;
    };

  template<typename _Iterator>
    requires __detail::__iter_without_nested_types<_Iterator>
       && __detail::__cpp17_iterator<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __diff
 { using type = void; };

      template<typename _Iter>
 requires requires
 { typename incrementable_traits<_Iter>::difference_type; }
 struct __diff<_Iter>
 {
   using type = typename incrementable_traits<_Iter>::difference_type;
 };

    public:
      using iterator_category = output_iterator_tag;
      using value_type = void;
      using difference_type = typename __diff<_Iterator>::type;
      using pointer = void;
      using reference = void;
    };

  namespace __detail
  {
    template<typename _Iter>
      struct __iter_concept_impl;


    template<typename _Iter>
      requires requires { typename __iter_traits<_Iter>::iterator_concept; }
      struct __iter_concept_impl<_Iter>
      { using type = typename __iter_traits<_Iter>::iterator_concept; };


    template<typename _Iter>
      requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
   && requires { typename __iter_traits<_Iter>::iterator_category; })
      struct __iter_concept_impl<_Iter>
      { using type = typename __iter_traits<_Iter>::iterator_category; };


    template<typename _Iter>
      requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
   && !requires { typename __iter_traits<_Iter>::iterator_category; }
   && __primary_traits_iter<_Iter>)
      struct __iter_concept_impl<_Iter>
      { using type = random_access_iterator_tag; };


    template<typename _Iter>
      struct __iter_concept_impl
      { };


    template<typename _Iter>
      using __iter_concept = typename __iter_concept_impl<_Iter>::type;

  template<typename _In>
    concept __indirectly_readable_impl = requires
      {
 typename iter_value_t<_In>;
 typename iter_reference_t<_In>;
 typename iter_rvalue_reference_t<_In>;
 requires same_as<iter_reference_t<const _In>,
    iter_reference_t<_In>>;
 requires same_as<iter_rvalue_reference_t<const _In>,
    iter_rvalue_reference_t<_In>>;
      }
      && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
      && common_reference_with<iter_reference_t<_In>&&,
         iter_rvalue_reference_t<_In>&&>
      && common_reference_with<iter_rvalue_reference_t<_In>&&,
          const iter_value_t<_In>&>;

  }


  template<typename _In>
    concept indirectly_readable
      = __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;

  namespace __detail
  {
    template<typename _Tp>
      struct __indirect_value
      { using type = iter_value_t<_Tp>&; };


  }

  template<typename _Tp>
    using __indirect_value_t = typename __detail::__indirect_value<_Tp>::type;

  template<indirectly_readable _Tp>
    using iter_common_reference_t
      = common_reference_t<iter_reference_t<_Tp>, __indirect_value_t<_Tp>>;


  template<typename _Out, typename _Tp>
    concept indirectly_writable = requires(_Out&& __o, _Tp&& __t)
      {
 *__o = std::forward<_Tp>(__t);
 *std::forward<_Out>(__o) = std::forward<_Tp>(__t);
 const_cast<const iter_reference_t<_Out>&&>(*__o)
   = std::forward<_Tp>(__t);
 const_cast<const iter_reference_t<_Out>&&>(*std::forward<_Out>(__o))
   = std::forward<_Tp>(__t);
      };

  namespace ranges::__detail
  {
    class __max_diff_type;
    class __max_size_type;

    __extension__
    template<typename _Tp>
      concept __is_signed_int128

 = same_as<_Tp, __int128>;




    __extension__
    template<typename _Tp>
      concept __is_unsigned_int128

 = same_as<_Tp, unsigned __int128>;




    template<typename _Tp>
      concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;

    template<typename _Tp>
      concept __integral_nonbool = integral<_Tp> && !__cv_bool<_Tp>;

    template<typename _Tp>
      concept __is_int128 = __is_signed_int128<_Tp> || __is_unsigned_int128<_Tp>;

    template<typename _Tp>
      concept __is_integer_like = __integral_nonbool<_Tp>
 || __is_int128<_Tp>
 || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;

    template<typename _Tp>
      concept __is_signed_integer_like = signed_integral<_Tp>
 || __is_signed_int128<_Tp>
 || same_as<_Tp, __max_diff_type>;

  }

  namespace __detail { using ranges::__detail::__is_signed_integer_like; }


  template<typename _Iter>
    concept weakly_incrementable = movable<_Iter>
      && requires(_Iter __i)
      {
 typename iter_difference_t<_Iter>;
 requires __detail::__is_signed_integer_like<iter_difference_t<_Iter>>;
 { ++__i } -> same_as<_Iter&>;
 __i++;
      };

  template<typename _Iter>
    concept incrementable = regular<_Iter> && weakly_incrementable<_Iter>
      && requires(_Iter __i) { { __i++ } -> same_as<_Iter>; };

  template<typename _Iter>
    concept input_or_output_iterator
      = requires(_Iter __i) { { *__i } -> __detail::__can_reference; }
 && weakly_incrementable<_Iter>;

  template<typename _Sent, typename _Iter>
    concept sentinel_for = semiregular<_Sent>
      && input_or_output_iterator<_Iter>
      && __detail::__weakly_eq_cmp_with<_Sent, _Iter>;

  template<typename _Sent, typename _Iter>
    inline constexpr bool disable_sized_sentinel_for = false;

  template<typename _Sent, typename _Iter>
    concept sized_sentinel_for = sentinel_for<_Sent, _Iter>
    && !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>>
    && requires(const _Iter& __i, const _Sent& __s)
    {
      { __s - __i } -> same_as<iter_difference_t<_Iter>>;
      { __i - __s } -> same_as<iter_difference_t<_Iter>>;
    };

  template<typename _Iter>
    concept input_iterator = input_or_output_iterator<_Iter>
      && indirectly_readable<_Iter>
      && requires { typename __detail::__iter_concept<_Iter>; }
      && derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;

  template<typename _Iter, typename _Tp>
    concept output_iterator = input_or_output_iterator<_Iter>
      && indirectly_writable<_Iter, _Tp>
      && requires(_Iter __i, _Tp&& __t) { *__i++ = std::forward<_Tp>(__t); };

  template<typename _Iter>
    concept forward_iterator = input_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag>
      && incrementable<_Iter> && sentinel_for<_Iter, _Iter>;

  template<typename _Iter>
    concept bidirectional_iterator = forward_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>,
        bidirectional_iterator_tag>
      && requires(_Iter __i)
      {
 { --__i } -> same_as<_Iter&>;
 { __i-- } -> same_as<_Iter>;
      };

  template<typename _Iter>
    concept random_access_iterator = bidirectional_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>,
        random_access_iterator_tag>
      && totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter>
      && requires(_Iter __i, const _Iter __j,
    const iter_difference_t<_Iter> __n)
      {
 { __i += __n } -> same_as<_Iter&>;
 { __j + __n } -> same_as<_Iter>;
 { __n + __j } -> same_as<_Iter>;
 { __i -= __n } -> same_as<_Iter&>;
 { __j - __n } -> same_as<_Iter>;
 { __j[__n] } -> same_as<iter_reference_t<_Iter>>;
      };

  template<typename _Iter>
    concept contiguous_iterator = random_access_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag>
      && is_lvalue_reference_v<iter_reference_t<_Iter>>
      && same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>>
      && requires(const _Iter& __i)
      {
 { std::to_address(__i) }
   -> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
      };





  template<typename _Fn, typename _Iter>
    concept indirectly_unary_invocable = indirectly_readable<_Iter>
      && copy_constructible<_Fn> && invocable<_Fn&, __indirect_value_t<_Iter>>
      && invocable<_Fn&, iter_reference_t<_Iter>>
      && common_reference_with<invoke_result_t<_Fn&, __indirect_value_t<_Iter>>,
          invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

  template<typename _Fn, typename _Iter>
    concept indirectly_regular_unary_invocable = indirectly_readable<_Iter>
      && copy_constructible<_Fn>
      && regular_invocable<_Fn&, __indirect_value_t<_Iter>>
      && regular_invocable<_Fn&, iter_reference_t<_Iter>>
      && common_reference_with<invoke_result_t<_Fn&, __indirect_value_t<_Iter>>,
          invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

  template<typename _Fn, typename _Iter>
    concept indirect_unary_predicate = indirectly_readable<_Iter>
      && copy_constructible<_Fn> && predicate<_Fn&, __indirect_value_t<_Iter>>
      && predicate<_Fn&, iter_reference_t<_Iter>>;

  template<typename _Fn, typename _I1, typename _I2>
    concept indirect_binary_predicate
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && predicate<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
      && predicate<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
      && predicate<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
      && predicate<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>;

  template<typename _Fn, typename _I1, typename _I2 = _I1>
    concept indirect_equivalence_relation
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && equivalence_relation<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
      && equivalence_relation<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
      && equivalence_relation<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
      && equivalence_relation<_Fn&, iter_reference_t<_I1>,
         iter_reference_t<_I2>>;

  template<typename _Fn, typename _I1, typename _I2 = _I1>
    concept indirect_strict_weak_order
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && strict_weak_order<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
      && strict_weak_order<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
      && strict_weak_order<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
      && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>;

  template<typename _Fn, typename... _Is>
    requires (indirectly_readable<_Is> && ...)
      && invocable<_Fn, iter_reference_t<_Is>...>
    using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;

  namespace __detail
  {
    template<typename _Iter, typename _Proj>
      struct __projected
      {
 struct __type
 {
   using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
   indirect_result_t<_Proj&, _Iter> operator*() const;



   using __projected_Iter = _Iter;
   using __projected_Proj = _Proj;
 };
      };

    template<weakly_incrementable _Iter, typename _Proj>
      struct __projected<_Iter, _Proj>
      {
 struct __type
 {
   using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
   using difference_type = iter_difference_t<_Iter>;
   indirect_result_t<_Proj&, _Iter> operator*() const;

   using __projected_Iter = _Iter;
   using __projected_Proj = _Proj;
 };
      };
  }


  template<indirectly_readable _Iter,
    indirectly_regular_unary_invocable<_Iter> _Proj>
    using projected = typename __detail::__projected<_Iter, _Proj>::__type;


  template<typename _Tp>
    requires same_as<_Tp, projected<typename _Tp::__projected_Iter,
        typename _Tp::__projected_Proj>>
    struct __detail::__indirect_value<_Tp>
    {
      using _Iter = typename _Tp::__projected_Iter;
      using _Proj = typename _Tp::__projected_Proj;
      using type = invoke_result_t<_Proj&, __indirect_value_t<_Iter>>;
    };
# 861 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/iterator_concepts.h" 3
  template<typename _In, typename _Out>
    concept indirectly_movable = indirectly_readable<_In>
      && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;

  template<typename _In, typename _Out>
    concept indirectly_movable_storable = indirectly_movable<_In, _Out>
      && indirectly_writable<_Out, iter_value_t<_In>>
      && movable<iter_value_t<_In>>
      && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
      && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;


  template<typename _In, typename _Out>
    concept indirectly_copyable = indirectly_readable<_In>
      && indirectly_writable<_Out, iter_reference_t<_In>>;

  template<typename _In, typename _Out>
    concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
      && indirectly_writable<_Out, iter_value_t<_In>&>
      && indirectly_writable<_Out, const iter_value_t<_In>&>
      && indirectly_writable<_Out, iter_value_t<_In>&&>
      && indirectly_writable<_Out, const iter_value_t<_In>&&>
      && copyable<iter_value_t<_In>>
      && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
      && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;

namespace ranges
{


  namespace __iswap
  {
    template<typename _It1, typename _It2>
      void iter_swap(_It1, _It2) = delete;



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

    template<typename _Xp, typename _Yp>
      constexpr iter_value_t<_Xp>
      __iter_exchange_move(_Xp&& __x, _Yp&& __y)
      noexcept(noexcept(iter_value_t<_Xp>(iter_move(__x)))
        && noexcept(*__x = iter_move(__y)))
      {
 iter_value_t<_Xp> __old_value(iter_move(__x));
 *__x = iter_move(__y);
 return __old_value;
      }

    struct _IterSwap
    {
    private:
      template<typename _Tp, typename _Up>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__adl_iswap<_Tp, _Up>)
     return noexcept(iter_swap(std::declval<_Tp>(),
          std::declval<_Up>()));
   else if constexpr (indirectly_readable<_Tp>
       && indirectly_readable<_Up>
       && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
     return noexcept(ranges::swap(*std::declval<_Tp>(),
      *std::declval<_Up>()));
   else
     return noexcept(*std::declval<_Tp>()
  = __iswap::__iter_exchange_move(std::declval<_Up>(),
          std::declval<_Tp>()));
 }

    public:
      template<typename _Tp, typename _Up>
 requires __adl_iswap<_Tp, _Up>
 || (indirectly_readable<remove_reference_t<_Tp>>
     && indirectly_readable<remove_reference_t<_Up>>
     && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
 || (indirectly_movable_storable<_Tp, _Up>
     && indirectly_movable_storable<_Up, _Tp>)
 constexpr void
 operator()(_Tp&& __e1, _Up&& __e2) const
 noexcept(_S_noexcept<_Tp, _Up>())
 {
   if constexpr (__adl_iswap<_Tp, _Up>)
     iter_swap(static_cast<_Tp&&>(__e1), static_cast<_Up&&>(__e2));
   else if constexpr (indirectly_readable<_Tp>
       && indirectly_readable<_Up>
       && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
     ranges::swap(*__e1, *__e2);
   else
     *__e1 = __iswap::__iter_exchange_move(__e2, __e1);
 }
    };
  }


  inline namespace _Cpo {
    inline constexpr __iswap::_IterSwap iter_swap{};
  }

}


  template<typename _I1, typename _I2 = _I1>
    concept indirectly_swappable
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && requires(const _I1 __i1, const _I2 __i2)
      {
 ranges::iter_swap(__i1, __i1);
 ranges::iter_swap(__i2, __i2);
 ranges::iter_swap(__i1, __i2);
 ranges::iter_swap(__i2, __i1);
      };


  template<typename _I1, typename _I2, typename _Rel, typename _P1 = identity,
    typename _P2 = identity>
    concept indirectly_comparable
      = indirect_binary_predicate<_Rel, projected<_I1, _P1>,
      projected<_I2, _P2>>;


  template<typename _Iter>
    concept permutable = forward_iterator<_Iter>
      && indirectly_movable_storable<_Iter, _Iter>
      && indirectly_swappable<_Iter, _Iter>;


  template<typename _I1, typename _I2, typename _Out,
    typename _Rel = ranges::less, typename _P1 = identity,
    typename _P2 = identity>
    concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      && weakly_incrementable<_Out> && indirectly_copyable<_I1, _Out>
      && indirectly_copyable<_I2, _Out>
      && indirect_strict_weak_order<_Rel, projected<_I1, _P1>,
        projected<_I2, _P2>>;


  template<typename _Iter, typename _Rel = ranges::less,
    typename _Proj = identity>
    concept sortable = permutable<_Iter>
      && indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>;

  struct unreachable_sentinel_t
  {
    template<weakly_incrementable _It>
      friend constexpr bool
      operator==(unreachable_sentinel_t, const _It&) noexcept
      { return false; }
  };

  inline constexpr unreachable_sentinel_t unreachable_sentinel{};


  namespace ranges::__access
  {
    using std::__detail::__class_or_enum;

    struct _Decay_copy final
    {
      template<typename _Tp>
 constexpr decay_t<_Tp>
 operator()(_Tp&& __t) const
 noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
 { return std::forward<_Tp>(__t); }
    } inline constexpr __decay_copy{};

    template<typename _Tp>
      concept __member_begin = requires(_Tp& __t)
 {
   { __decay_copy(__t.begin()) } -> input_or_output_iterator;
 };


    void begin() = delete;

    template<typename _Tp>
      concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(begin(__t)) } -> input_or_output_iterator;
 };



    template<typename _Tp>
      requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
      auto
      __begin(_Tp& __t)
      {
 if constexpr (is_array_v<_Tp>)
   return __t + 0;
 else if constexpr (__member_begin<_Tp&>)
   return __t.begin();
 else
   return begin(__t);
      }
  }

  namespace __detail
  {

    template<typename _Tp>
      using __range_iter_t
 = decltype(ranges::__access::__begin(std::declval<_Tp&>()));

  }



}
#pragma GCC diagnostic pop
# 74 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{
# 95 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  struct input_iterator_tag { };


  struct output_iterator_tag { };


  struct forward_iterator_tag : public input_iterator_tag { };



  struct bidirectional_iterator_tag : public forward_iterator_tag { };



  struct random_access_iterator_tag : public bidirectional_iterator_tag { };



  struct contiguous_iterator_tag : public random_access_iterator_tag { };
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct [[__deprecated__]] iterator
    {

      typedef _Category iterator_category;

      typedef _Tp value_type;

      typedef _Distance difference_type;

      typedef _Pointer pointer;

      typedef _Reference reference;
    };
# 151 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits;




  template<typename _Iterator, typename = __void_t<>>
    struct __iterator_traits { };
# 178 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits
    : public __iterator_traits<_Iterator> { };
# 196 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  template<typename _Tp>

    requires is_object_v<_Tp>

    struct iterator_traits<_Tp*>
    {
      using iterator_concept = contiguous_iterator_tag;
      using iterator_category = random_access_iterator_tag;
      using value_type = remove_cv_t<_Tp>;
      using difference_type = ptrdiff_t;
      using pointer = _Tp*;
      using reference = _Tp&;
    };
# 237 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
  template<typename _Iter>
    __attribute__((__always_inline__))
    inline constexpr
    typename iterator_traits<_Iter>::iterator_category
    __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }




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

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


  template<typename _InIter>
    concept __has_input_iter_cat
      = is_convertible_v<__iter_category_t<_InIter>, input_iterator_tag>;


  template<typename _It,
    typename _Cat = __iter_category_t<_It>>
    struct __is_random_access_iter
      : is_base_of<random_access_iterator_tag, _Cat>
    {
      typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
      enum { __value = _Base::value };
    };
# 278 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_types.h" 3
}
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 1 3
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/concept_check.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/concept_check.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wvariadic-macros"
# 86 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/concept_check.h" 3
#pragma GCC diagnostic pop
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/debug/assertions.h" 1 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 2 3


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




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


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



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

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



      return __last - __first;
    }



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

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




  template<typename _OutputIterator>
    void
    __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete;
# 146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    [[__nodiscard__]] __attribute__((__always_inline__))
    inline constexpr
    typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

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

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


      do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
      while (__n--)
 ++__i;
    }

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



      if (__n > 0)
        while (__n--)
   ++__i;
      else
        while (__n++)
   --__i;
    }

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



      if (__builtin_constant_p(__n) && __n == 1)
 ++__i;
      else if (__builtin_constant_p(__n) && __n == -1)
 --__i;
      else
 __i += __n;
    }



  template<typename _OutputIterator, typename _Distance>
    void
    __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete;
# 219 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    __attribute__((__always_inline__))
    inline constexpr void
    advance(_InputIterator& __i, _Distance __n)
    {

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



  template<typename _InputIterator>
    [[__nodiscard__]] [[__gnu__::__always_inline__]]
    inline constexpr _InputIterator
    next(_InputIterator __x, typename
  iterator_traits<_InputIterator>::difference_type __n = 1)
    {


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

  template<typename _BidirectionalIterator>
    [[__nodiscard__]] [[__gnu__::__always_inline__]]
    inline constexpr _BidirectionalIterator
    prev(_BidirectionalIterator __x, typename
  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
    {



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




}
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 2 3
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Tp>
    constexpr inline void
    destroy_at(_Tp* __location)
    {
      if constexpr (202002L > 201703L && is_array_v<_Tp>)
 {
   for (auto& __x : *__location)
     std::destroy_at(std::__addressof(__x));
 }
      else
 __location->~_Tp();
    }


  template<typename _Tp, typename... _Args>
    requires (!is_unbounded_array_v<_Tp>)
      && requires { ::new((void*)0) _Tp(std::declval<_Args>()...); }
    constexpr _Tp*
    construct_at(_Tp* __location, _Args&&... __args)
    noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
    {
      void* __loc = __location;


      if constexpr (is_array_v<_Tp>)
 {
   static_assert(sizeof...(_Args) == 0, "std::construct_at for array "
         "types must not use any arguments to initialize the "
         "array");
   return ::new(__loc) _Tp[1]();
 }
      else
 return ::new(__loc) _Tp(std::forward<_Args>(__args)...);
    }
# 120 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
  template<typename _Tp, typename... _Args>
    constexpr
    inline void
    _Construct(_Tp* __p, _Args&&... __args)
    {

      if (std::__is_constant_evaluated())
 {

   std::construct_at(__p, std::forward<_Args>(__args)...);
   return;
 }

      ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...);
    }
# 146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
  template<typename _T1>

    inline void
    _Construct_novalue(_T1* __p)
    { ::new(static_cast<void*>(__p)) _T1; }

  template<typename _ForwardIterator>
    constexpr void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last);




  template<typename _Tp>
    constexpr inline void
    _Destroy(_Tp* __pointer)
    {

      std::destroy_at(__pointer);



    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
# 200 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    constexpr inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");
      if constexpr (!__has_trivial_destructor(_Value_type))
 for (; __first != __last; ++__first)
   std::_Destroy(std::__addressof(*__first));

      else if (std::__is_constant_evaluated())
 for (; __first != __last; ++__first)
   std::destroy_at(std::__addressof(*__first));





    }
# 256 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_construct.h" 3
  template<typename _ForwardIterator, typename _Size>
    constexpr inline _ForwardIterator
    _Destroy_n(_ForwardIterator __first, _Size __count)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");
      if constexpr (!__has_trivial_destructor(_Value_type))
 for (; __count > 0; (void)++__first, --__count)
   std::_Destroy(std::__addressof(*__first));

      else if (std::__is_constant_evaluated())
 for (; __count > 0; (void)++__first, --__count)
   std::destroy_at(std::__addressof(*__first));

      else
 std::advance(__first, __count);
      return __first;




    }
#pragma GCC diagnostic pop


  template <typename _ForwardIterator>
    constexpr inline void
    destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      std::_Destroy(__first, __last);
    }

  template <typename _ForwardIterator, typename _Size>
    constexpr inline _ForwardIterator
    destroy_n(_ForwardIterator __first, _Size __count)
    {
      return std::_Destroy_n(__first, __count);
    }



}
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 2 3






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


#pragma GCC diagnostic push


#pragma GCC diagnostic ignored "-Warray-bounds"
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

    };
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;

      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type state_type;


      using comparison_category = std::strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2)
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static constexpr std::size_t
      length(const char_type* __s);

      static constexpr const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static constexpr char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      static constexpr char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }


      static constexpr int_type
      eof()
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }

    };

  template<typename _CharT>
    constexpr int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    constexpr std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    constexpr const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      if (__n == 0)
 return __s1;

      if (std::__is_constant_evaluated())
 {

   if (__builtin_constant_p(__s2 < __s1)
  && __s1 > __s2 && __s1 < (__s2 + __n))
     {
       do
  {
    --__n;
    assign(__s1[__n], __s2[__n]);
  }
       while (__n > 0);
     }
   else
     copy(__s1, __s2, __n);
   return __s1;
 }

      __builtin_memmove(__s1, __s2, __n * sizeof(char_type));
      return __s1;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      if (__n == 0)
 return __s1;

      if (std::__is_constant_evaluated())
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     std::construct_at(__s1 + __i, __s2[__i]);
   return __s1;
 }

      __builtin_memcpy(__s1, __s2, __n * sizeof(char_type));
      return __s1;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {

      if (std::__is_constant_evaluated())
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     std::construct_at(__s + __i, __a);
   return __s;
 }


      if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT))
 {
   if (__n)
     {
       unsigned char __c;
       __builtin_memcpy(&__c, __builtin_addressof(__a), 1);
       __builtin_memset(__s, __c, __n);
     }
 }
      else
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     __s[__i] = __a;
 }
      return __s;
    }


}

namespace std __attribute__ ((__visibility__ ("default")))
{
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef int int_type;

      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      {

 return (static_cast<unsigned char>(__c1)
  < static_cast<unsigned char>(__c2));
      }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   {
     for (size_t __i = 0; __i < __n; ++__i)
       if (lt(__s1[__i], __s2[__i]))
  return -1;
       else if (lt(__s2[__i], __s1[__i]))
  return 1;
     return 0;
   }

 return __builtin_memcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return __builtin_strlen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return static_cast<char_type>(__c); }



      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return (__c == eof()) ? 0 : __c; }

  };




  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t char_type;
      typedef wint_t int_type;

      typedef streamoff off_type;
      typedef wstreampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return wmemcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return wcslen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return wmemchr(__s, __a, __n);
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return wmemmove(__s1, __s2, __n);
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return wmemcpy(__s1, __s2, __n);
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

 return wmemset(__s, __a, __n);
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>((0xffffffffu)); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

  };







  template<>
    struct char_traits<char8_t>
    {
      typedef char8_t char_type;
      typedef unsigned int int_type;

      typedef u8streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return __builtin_memcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return __builtin_strlen((const char*)__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

    };



}



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


  template<>
    struct char_traits<char16_t>
    {
      typedef char16_t char_type;

      typedef unsigned short int_type;




      typedef streamoff off_type;
      typedef u16streampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return __c == eof() ? int_type(0xfffd) : int_type(__c); }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }





    };

  template<>
    struct char_traits<char32_t>
    {
      typedef char32_t char_type;

      typedef unsigned int int_type;




      typedef streamoff off_type;
      typedef u32streampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

    };


  namespace __detail
  {
    template<typename _ChTraits>
      constexpr auto
      __char_traits_cmp_cat(int __cmp) noexcept
      {
 if constexpr (requires { typename _ChTraits::comparison_category; })
   {
     using _Cat = typename _ChTraits::comparison_category;
     static_assert( !is_void_v<common_comparison_category_t<_Cat>> );
     return static_cast<_Cat>(__cmp <=> 0);
   }
 else
   return static_cast<weak_ordering>(__cmp <=> 0);
      }
  }


#pragma GCC diagnostic pop


}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/localefwd.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/localefwd.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++locale.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++locale.h" 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/clocale" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/clocale" 3
# 1 "/usr/include/locale.h" 1 3 4
# 28 "/usr/include/locale.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 29 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4

extern "C" {
# 51 "/usr/include/locale.h" 3 4
struct lconv
{


  char *decimal_point;
  char *thousands_sep;





  char *grouping;





  char *int_curr_symbol;
  char *currency_symbol;
  char *mon_decimal_point;
  char *mon_thousands_sep;
  char *mon_grouping;
  char *positive_sign;
  char *negative_sign;
  char int_frac_digits;
  char frac_digits;

  char p_cs_precedes;

  char p_sep_by_space;

  char n_cs_precedes;

  char n_sep_by_space;






  char p_sign_posn;
  char n_sign_posn;


  char int_p_cs_precedes;

  char int_p_sep_by_space;

  char int_n_cs_precedes;

  char int_n_sep_by_space;






  char int_p_sign_posn;
  char int_n_sign_posn;
# 118 "/usr/include/locale.h" 3 4
};



extern char *setlocale (int __category, const char *__locale) noexcept (true);


extern struct lconv *localeconv (void) noexcept (true);
# 141 "/usr/include/locale.h" 3 4
extern locale_t newlocale (int __category_mask, const char *__locale,
      locale_t __base) noexcept (true);
# 176 "/usr/include/locale.h" 3 4
extern locale_t duplocale (locale_t __dataset) noexcept (true);



extern void freelocale (locale_t __dataset) noexcept (true);






extern locale_t uselocale (locale_t __dataset) noexcept (true);







}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/clocale" 2 3





namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++locale.h" 2 3






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


  extern "C" __typeof(uselocale) __uselocale;


}


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


  typedef __locale_t __c_locale;
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++locale.h" 3
  inline int
  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
     char* __out,
     const int __size __attribute__ ((__unused__)),
     const char* __fmt, ...)
  {

    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  }







}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/localefwd.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cctype" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cctype" 3
# 1 "/usr/include/ctype.h" 1 3 4
# 26 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 27 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/types.h" 2 3 4
# 1 "/usr/include/bits/timesize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;






typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;



typedef long int __quad_t;
typedef unsigned long int __u_quad_t;







typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 142 "/usr/include/bits/types.h" 2 3 4
# 1 "/usr/include/bits/time64.h" 1 3 4
# 143 "/usr/include/bits/types.h" 2 3 4


typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __suseconds64_t;

typedef int __daddr_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;


typedef long int __fsword_t;

typedef long int __ssize_t;


typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;



typedef __off64_t __loff_t;
typedef char *__caddr_t;


typedef long int __intptr_t;


typedef unsigned int __socklen_t;




typedef int __sig_atomic_t;
# 27 "/usr/include/ctype.h" 2 3 4

extern "C" {
# 39 "/usr/include/ctype.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
# 40 "/usr/include/ctype.h" 2 3 4






enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 79 "/usr/include/ctype.h" 3 4
extern const unsigned short int **__ctype_b_loc (void)
     noexcept (true) __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
     noexcept (true) __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
     noexcept (true) __attribute__ ((__const__));
# 108 "/usr/include/ctype.h" 3 4
extern int isalnum (int) noexcept (true);
extern int isalpha (int) noexcept (true);
extern int iscntrl (int) noexcept (true);
extern int isdigit (int) noexcept (true);
extern int islower (int) noexcept (true);
extern int isgraph (int) noexcept (true);
extern int isprint (int) noexcept (true);
extern int ispunct (int) noexcept (true);
extern int isspace (int) noexcept (true);
extern int isupper (int) noexcept (true);
extern int isxdigit (int) noexcept (true);



extern int tolower (int __c) noexcept (true);


extern int toupper (int __c) noexcept (true);




extern int isblank (int) noexcept (true);




extern int isctype (int __c, int __mask) noexcept (true);






extern int isascii (int __c) noexcept (true);



extern int toascii (int __c) noexcept (true);



extern int _toupper (int) noexcept (true);
extern int _tolower (int) noexcept (true);
# 251 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, locale_t) noexcept (true);
extern int isalpha_l (int, locale_t) noexcept (true);
extern int iscntrl_l (int, locale_t) noexcept (true);
extern int isdigit_l (int, locale_t) noexcept (true);
extern int islower_l (int, locale_t) noexcept (true);
extern int isgraph_l (int, locale_t) noexcept (true);
extern int isprint_l (int, locale_t) noexcept (true);
extern int ispunct_l (int, locale_t) noexcept (true);
extern int isspace_l (int, locale_t) noexcept (true);
extern int isupper_l (int, locale_t) noexcept (true);
extern int isxdigit_l (int, locale_t) noexcept (true);

extern int isblank_l (int, locale_t) noexcept (true);



extern int __tolower_l (int __c, locale_t __l) noexcept (true);
extern int tolower_l (int __c, locale_t __l) noexcept (true);


extern int __toupper_l (int __c, locale_t __l) noexcept (true);
extern int toupper_l (int __c, locale_t __l) noexcept (true);
# 327 "/usr/include/ctype.h" 3 4
}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cctype" 2 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/localefwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/localefwd.h" 3
  class locale;

  template<typename _Facet>
    bool
    has_facet(const locale&) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale&);


  template<typename _CharT>
    bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    bool
    isgraph(_CharT, const locale&);


  template<typename _CharT>
    bool
    isblank(_CharT, const locale&);


  template<typename _CharT>
    _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    _CharT
    tolower(_CharT, const locale&);


  struct ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, char, mbstate_t>;


  template<> class codecvt<char16_t, char, mbstate_t>;
  template<> class codecvt<char32_t, char, mbstate_t>;

  template<> class codecvt<char16_t, char8_t, mbstate_t>;
  template<> class codecvt<char32_t, char8_t, mbstate_t>;


  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;



  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;

namespace __cxx11 {
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;
}

namespace __cxx11 {

  template<typename _CharT>
    class collate;
  template<typename _CharT>
    class collate_byname;
}


  class time_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
}
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
}
namespace __cxx11 {
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;
}


  struct messages_base;
namespace __cxx11 {
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;
}


}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr.h" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 30 "/usr/include/sched.h" 2 3 4

# 1 "/usr/include/bits/types/time_t.h" 1 3 4
# 10 "/usr/include/bits/types/time_t.h" 3 4
typedef __time_t time_t;
# 32 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4
# 11 "/usr/include/bits/types/struct_timespec.h" 3 4
struct timespec
{



  __time_t tv_sec;




  __syscall_slong_t tv_nsec;
# 31 "/usr/include/bits/types/struct_timespec.h" 3 4
};
# 33 "/usr/include/sched.h" 2 3 4





typedef __pid_t pid_t;




# 1 "/usr/include/bits/sched.h" 1 3 4
# 60 "/usr/include/bits/sched.h" 3 4
# 1 "/usr/include/linux/sched/types.h" 1 3 4




# 1 "/usr/include/linux/types.h" 1 3 4




# 1 "/usr/include/asm/types.h" 1 3 4
# 1 "/usr/include/asm-generic/types.h" 1 3 4






# 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
# 12 "/usr/include/asm-generic/int-ll64.h" 3 4
# 1 "/usr/include/asm/bitsperlong.h" 1 3 4
# 11 "/usr/include/asm/bitsperlong.h" 3 4
# 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
# 12 "/usr/include/asm/bitsperlong.h" 2 3 4
# 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4







typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;


__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
# 8 "/usr/include/asm-generic/types.h" 2 3 4
# 2 "/usr/include/asm/types.h" 2 3 4
# 6 "/usr/include/linux/types.h" 2 3 4



# 1 "/usr/include/linux/posix_types.h" 1 3 4




# 1 "/usr/include/linux/stddef.h" 1 3 4
# 6 "/usr/include/linux/posix_types.h" 2 3 4
# 25 "/usr/include/linux/posix_types.h" 3 4
typedef struct {
 unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;
typedef int __kernel_mqd_t;

# 1 "/usr/include/asm/posix_types.h" 1 3 4






# 1 "/usr/include/asm/posix_types_64.h" 1 3 4
# 11 "/usr/include/asm/posix_types_64.h" 3 4
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;


typedef unsigned long __kernel_old_dev_t;


# 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
# 15 "/usr/include/asm-generic/posix_types.h" 3 4
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;



typedef __kernel_ulong_t __kernel_ino_t;



typedef unsigned int __kernel_mode_t;



typedef int __kernel_pid_t;



typedef int __kernel_ipc_pid_t;



typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;



typedef __kernel_long_t __kernel_suseconds_t;



typedef int __kernel_daddr_t;



typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
# 72 "/usr/include/asm-generic/posix_types.h" 3 4
typedef __kernel_ulong_t __kernel_size_t;
typedef __kernel_long_t __kernel_ssize_t;
typedef __kernel_long_t __kernel_ptrdiff_t;




typedef struct {
 int val[2];
} __kernel_fsid_t;





typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_old_time_t;
typedef __kernel_long_t __kernel_time_t;
typedef long long __kernel_time64_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
# 19 "/usr/include/asm/posix_types_64.h" 2 3 4
# 8 "/usr/include/asm/posix_types.h" 2 3 4
# 37 "/usr/include/linux/posix_types.h" 2 3 4
# 10 "/usr/include/linux/types.h" 2 3 4


typedef __signed__ __int128 __s128 __attribute__((aligned(16)));
typedef unsigned __int128 __u128 __attribute__((aligned(16)));
# 28 "/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;
# 51 "/usr/include/linux/types.h" 3 4
typedef unsigned __poll_t;
# 6 "/usr/include/linux/sched/types.h" 2 3 4

struct __glibc_mask_sched_param {
 int sched_priority;
};
# 102 "/usr/include/linux/sched/types.h" 3 4
struct sched_attr {
 __u32 size;

 __u32 sched_policy;
 __u64 sched_flags;


 __s32 sched_nice;


 __u32 sched_priority;


 __u64 sched_runtime;
 __u64 sched_deadline;
 __u64 sched_period;


 __u32 sched_util_min;
 __u32 sched_util_max;

};
# 61 "/usr/include/bits/sched.h" 2 3 4
# 119 "/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;
};
# 120 "/usr/include/bits/sched.h" 2 3 4

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) noexcept (true);


extern int unshare (int __flags) noexcept (true);


extern int sched_getcpu (void) noexcept (true);


extern int getcpu (unsigned int *, unsigned int *) noexcept (true);


extern int setns (int __fd, int __nstype) noexcept (true);


int sched_setattr (pid_t tid, struct sched_attr *attr, unsigned int flags)
  noexcept (true) __attribute__ ((__nonnull__ (2)));



int sched_getattr (pid_t tid, struct sched_attr *attr, unsigned int size,
     unsigned int flags)
  noexcept (true) __attribute__ ((__nonnull__ (2)));



}
# 44 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/bits/cpu-set.h" 1 3 4
# 32 "/usr/include/bits/cpu-set.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 115 "/usr/include/bits/cpu-set.h" 3 4
extern "C" {

extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
     noexcept (true);
extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ;
extern void __sched_cpufree (cpu_set_t *__set) noexcept (true);

}
# 45 "/usr/include/sched.h" 2 3 4






extern "C" {


extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
     noexcept (true);


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true);


extern int sched_setscheduler (__pid_t __pid, int __policy,
          const struct sched_param *__param) noexcept (true);


extern int sched_getscheduler (__pid_t __pid) noexcept (true);


extern int sched_yield (void) noexcept (true);


extern int sched_get_priority_max (int __algorithm) noexcept (true);


extern int sched_get_priority_min (int __algorithm) noexcept (true);



extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true);
# 130 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         const cpu_set_t *__cpuset) noexcept (true);


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) noexcept (true);


}
# 23 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 30 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 73 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/timex.h" 1 3 4
# 22 "/usr/include/bits/timex.h" 3 4
# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4







struct timeval
{




  __time_t tv_sec;
  __suseconds_t tv_usec;

};
# 23 "/usr/include/bits/timex.h" 2 3 4



struct timex
{
# 58 "/usr/include/bits/timex.h" 3 4
  unsigned int modes;
  __syscall_slong_t offset;
  __syscall_slong_t freq;
  __syscall_slong_t maxerror;
  __syscall_slong_t esterror;
  int status;
  __syscall_slong_t constant;
  __syscall_slong_t precision;
  __syscall_slong_t tolerance;
  struct timeval time;
  __syscall_slong_t tick;
  __syscall_slong_t ppsfreq;
  __syscall_slong_t jitter;
  int shift;
  __syscall_slong_t stabil;
  __syscall_slong_t jitcnt;
  __syscall_slong_t calcnt;
  __syscall_slong_t errcnt;
  __syscall_slong_t stbcnt;

  int tai;


  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32;

};
# 74 "/usr/include/bits/time.h" 2 3 4

extern "C" {


extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true);
# 90 "/usr/include/bits/time.h" 3 4
}
# 34 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/types/clock_t.h" 1 3 4






typedef __clock_t clock_t;
# 38 "/usr/include/time.h" 2 3 4

# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4






struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  const char *tm_zone;




};
# 40 "/usr/include/time.h" 2 3 4






# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4






typedef __clockid_t clockid_t;
# 47 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/bits/types/timer_t.h" 1 3 4






typedef __timer_t timer_t;
# 48 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4







struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };
# 49 "/usr/include/time.h" 2 3 4
struct sigevent;
# 68 "/usr/include/time.h" 3 4
extern "C" {



extern clock_t clock (void) noexcept (true);



extern time_t time (time_t *__timer) noexcept (true);


extern double difftime (time_t __time1, time_t __time0)
     noexcept (true) __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) noexcept (true);
# 100 "/usr/include/time.h" 3 4
extern size_t strftime (char *__restrict __s, size_t __maxsize,
   const char *__restrict __format,
   const struct tm *__restrict __tp) noexcept (true);




extern char *strptime (const char *__restrict __s,
         const char *__restrict __fmt, struct tm *__tp)
     noexcept (true);






extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
     const char *__restrict __format,
     const struct tm *__restrict __tp,
     locale_t __loc) noexcept (true);



extern char *strptime_l (const char *__restrict __s,
    const char *__restrict __fmt, struct tm *__tp,
    locale_t __loc) noexcept (true);






extern struct tm *gmtime (const time_t *__timer) noexcept (true);



extern struct tm *localtime (const time_t *__timer) noexcept (true);
# 154 "/usr/include/time.h" 3 4
extern struct tm *gmtime_r (const time_t *__restrict __timer,
       struct tm *__restrict __tp) noexcept (true);



extern struct tm *localtime_r (const time_t *__restrict __timer,
          struct tm *__restrict __tp) noexcept (true);
# 179 "/usr/include/time.h" 3 4
extern char *asctime (const struct tm *__tp) noexcept (true);



extern char *ctime (const time_t *__timer) noexcept (true);
# 197 "/usr/include/time.h" 3 4
extern char *asctime_r (const struct tm *__restrict __tp,
   char *__restrict __buf) noexcept (true);



extern char *ctime_r (const time_t *__restrict __timer,
        char *__restrict __buf) noexcept (true);
# 217 "/usr/include/time.h" 3 4
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) noexcept (true);



extern int daylight;
extern long int timezone;
# 249 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) noexcept (true);

extern time_t timelocal (struct tm *__tp) noexcept (true);
# 262 "/usr/include/time.h" 3 4
extern int dysize (int __year) noexcept (true) __attribute__ ((__const__));
# 272 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
        struct timespec *__remaining);


extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true);


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) noexcept (true);


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     noexcept (true);
# 311 "/usr/include/time.h" 3 4
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       const struct timespec *__req,
       struct timespec *__rem);
# 326 "/usr/include/time.h" 3 4
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true);




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) noexcept (true);


extern int timer_delete (timer_t __timerid) noexcept (true);



extern int timer_settime (timer_t __timerid, int __flags,
     const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) noexcept (true);


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     noexcept (true);
# 364 "/usr/include/time.h" 3 4
extern int timer_getoverrun (timer_t __timerid) noexcept (true);






extern int timespec_get (struct timespec *__ts, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 387 "/usr/include/time.h" 3 4
extern int timespec_getres (struct timespec *__ts, int __base)
     noexcept (true);
# 413 "/usr/include/time.h" 3 4
extern int getdate_err;
# 422 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 436 "/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/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4

# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4
# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4
typedef union
{
  __extension__ unsigned long long int __value64;
  struct
  {
    unsigned int __low;
    unsigned int __high;
  } __value32;
} __atomic_wide_counter;
# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4




typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;

typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 76 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/bits/struct_mutex.h" 3 4
struct __pthread_mutex_s
{
  int __lock;
  unsigned int __count;
  int __owner;

  unsigned int __nusers;



  int __kind;

  short __spins;
  short __elision;
  __pthread_list_t __list;
# 53 "/usr/include/bits/struct_mutex.h" 3 4
};
# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4
# 89 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/bits/struct_rwlock.h" 3 4
struct __pthread_rwlock_arch_t
{
  unsigned int __readers;
  unsigned int __writers;
  unsigned int __wrphase_futex;
  unsigned int __writers_futex;
  unsigned int __pad3;
  unsigned int __pad4;

  int __cur_writer;
  int __shared;
  signed char __rwelision;




  unsigned char __pad1[7];


  unsigned long int __pad2;


  unsigned int __flags;
# 55 "/usr/include/bits/struct_rwlock.h" 3 4
};
# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4




struct __pthread_cond_s
{
  __atomic_wide_counter __wseq;
  __atomic_wide_counter __g1_start;
  unsigned int __glibc_unused___g_refs[2] ;
  unsigned int __g_size[2];
  unsigned int __g1_orig_size;
  unsigned int __wrefs;
  unsigned int __g_signals[2];
};

typedef unsigned int __tss_t;
typedef unsigned long int __thrd_t;

typedef struct
{
  int __data ;
} __once_flag;
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4



typedef unsigned long int pthread_t;




typedef union
{
  char __size[4];
  int __align;
} pthread_mutexattr_t;




typedef union
{
  char __size[4];
  int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;


union pthread_attr_t
{
  char __size[56];
  long int __align;
};

typedef union pthread_attr_t pthread_attr_t;




typedef union
{
  struct __pthread_mutex_s __data;
  char __size[40];
  long int __align;
} pthread_mutex_t;


typedef union
{
  struct __pthread_cond_s __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;





typedef union
{
  struct __pthread_rwlock_arch_t __data;
  char __size[56];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[32];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 27 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 26 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4




typedef struct
{
  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 31 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4
# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4
struct __jmp_buf_tag
  {




    __jmp_buf __jmpbuf;
    int __mask_was_saved;
    __sigset_t __saved_mask;
  };
# 32 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4
# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4
extern "C" {
extern long int __sysconf (int __name) noexcept (true);
}
# 34 "/usr/include/pthread.h" 2 3 4



enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};



enum
{
  PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

  ,
  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};




enum
{
  PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_ROBUST,
  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};





enum
{
  PTHREAD_PRIO_NONE,
  PTHREAD_PRIO_INHERIT,
  PTHREAD_PRIO_PROTECT
};
# 104 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 124 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 159 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 197 "/usr/include/pthread.h" 3 4
extern "C" {




extern int pthread_create (pthread_t *__restrict __newthread,
      const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));





extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));







extern int pthread_join (pthread_t __th, void **__thread_return);




extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true);
# 233 "/usr/include/pthread.h" 3 4
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     const struct timespec *__abstime);
# 243 "/usr/include/pthread.h" 3 4
extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
                                 clockid_t __clockid,
     const struct timespec *__abstime);
# 269 "/usr/include/pthread.h" 3 4
extern int pthread_detach (pthread_t __th) noexcept (true);



extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
  noexcept (true) __attribute__ ((__const__));







extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
     int *__detachstate)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
          size_t *__guardsize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
           struct sched_param *__restrict __param)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           const struct sched_param *__restrict
           __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     const cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));


extern int pthread_getattr_default_np (pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr,
           const __sigset_t *sigmask);




extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr,
           __sigset_t *sigmask);







extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      const struct sched_param *__param)
     noexcept (true) __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     noexcept (true);




extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
          size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2)));


extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (2)));





extern int pthread_getconcurrency (void) noexcept (true);


extern int pthread_setconcurrency (int __level) noexcept (true);



extern int pthread_yield (void) noexcept (true);

extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield")
  __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead")));
# 489 "/usr/include/pthread.h" 3 4
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       const cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 509 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 521 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);



extern int pthread_setcanceltype (int __type, int *__oldtype);


extern int pthread_cancel (pthread_t __th);




extern void pthread_testcancel (void);




struct __cancel_jmp_buf_tag
{
  __jmp_buf __cancel_jmp_buf;
  int __mask_was_saved;
};

typedef struct
{
  struct __cancel_jmp_buf_tag __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 557 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;
};




class __pthread_cleanup_class
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;

 public:
  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
  void __setdoit (int __newval) { __do_it = __newval; }
  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
        &__cancel_type); }
  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
};
# 773 "/usr/include/pthread.h" 3 4
extern int __sigsetjmp (struct __jmp_buf_tag __env[1],
   int __savemask) noexcept (true);






extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          const pthread_mutexattr_t *__mutexattr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        const struct timespec *__restrict
        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 817 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
        clockid_t __clockid,
        const struct timespec *__restrict
        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 835 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));




extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1)))

  __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent")));
# 874 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
     int *__robustness)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust")));







extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust")));
# 967 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    const pthread_rwlockattr_t *__restrict
    __attr) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 1004 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 1023 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 1051 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 1071 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) noexcept (true) __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         const pthread_condattr_t *__restrict __cond_attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 1145 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 3)));
# 1171 "/usr/include/pthread.h" 3 4
extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       __clockid_t __clock_id,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 4)));
# 1194 "/usr/include/pthread.h" 3 4
extern int pthread_condattr_init (pthread_condattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1230 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1297 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) noexcept (true);


extern void *pthread_getspecific (pthread_key_t __key) noexcept (true);


extern int pthread_setspecific (pthread_key_t __key,
    const void *__pointer)
  noexcept (true) ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (2)));




extern pid_t pthread_gettid_np (pthread_t __thread_id);
# 1337 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) noexcept (true);




extern __inline __attribute__ ((__gnu_inline__)) int
 pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true)
{
  return __thread1 == __thread2;
}


}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 2 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 345 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 3
inline __attribute__((__always_inline__)) int
__gthread_active_p (void)
{
  return 1;
}
# 705 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 3
inline __attribute__((__always_inline__)) int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return pthread_create (__threadid, __null, __func, __args);
}

inline __attribute__((__always_inline__)) int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return pthread_join (__threadid, __value_ptr);
}

inline __attribute__((__always_inline__)) int
__gthread_detach (__gthread_t __threadid)
{
  return pthread_detach (__threadid);
}

inline __attribute__((__always_inline__)) int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return pthread_equal (__t1, __t2);
}

inline __attribute__((__always_inline__)) __gthread_t
__gthread_self (void)
{
  return pthread_self ();
}

inline __attribute__((__always_inline__)) int
__gthread_yield (void)
{
  return sched_yield ();
}

inline __attribute__((__always_inline__)) int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (__once, __func);
  else
    return -1;
}

inline __attribute__((__always_inline__)) int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return pthread_key_create (__key, __dtor);
}

inline __attribute__((__always_inline__)) int
__gthread_key_delete (__gthread_key_t __key)
{
  return pthread_key_delete (__key);
}

inline __attribute__((__always_inline__)) void *
__gthread_getspecific (__gthread_key_t __key)
{
  return pthread_getspecific (__key);
}

inline __attribute__((__always_inline__)) int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return pthread_setspecific (__key, __ptr);
}

inline __attribute__((__always_inline__)) void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    pthread_mutex_init (__mutex, __null);
}

inline __attribute__((__always_inline__)) int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_destroy (__mutex);
  else
    return 0;
}

inline __attribute__((__always_inline__)) int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_lock (__mutex);
  else
    return 0;
}

inline __attribute__((__always_inline__)) int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_trylock (__mutex);
  else
    return 0;
}


inline __attribute__((__always_inline__)) int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
      const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}


inline __attribute__((__always_inline__)) int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (__mutex);
  else
    return 0;
}
# 854 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 3
inline __attribute__((__always_inline__)) int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_lock (__mutex);
}

inline __attribute__((__always_inline__)) int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_trylock (__mutex);
}


inline __attribute__((__always_inline__)) int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
         const __gthread_time_t *__abs_timeout)
{
  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}


inline __attribute__((__always_inline__)) int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_unlock (__mutex);
}

inline __attribute__((__always_inline__)) int
__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_destroy (__mutex);
}
# 896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr-default.h" 3
inline __attribute__((__always_inline__)) int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return pthread_cond_broadcast (__cond);
}

inline __attribute__((__always_inline__)) int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return pthread_cond_signal (__cond);
}

inline __attribute__((__always_inline__)) int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return pthread_cond_wait (__cond, __mutex);
}

inline __attribute__((__always_inline__)) int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
     const __gthread_time_t *__abs_timeout)
{
  return pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

inline __attribute__((__always_inline__)) int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
          __gthread_recursive_mutex_t *__mutex)
{
  return __gthread_cond_wait (__cond, __mutex);
}

inline __attribute__((__always_inline__)) int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
  return pthread_cond_destroy (__cond);
}
# 158 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/atomic_word.h" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 2 3

# 1 "/usr/include/sys/single_threaded.h" 1 3 4
# 24 "/usr/include/sys/single_threaded.h" 3 4
extern "C" {




extern char __libc_single_threaded;

}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 2 3


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


  __attribute__((__always_inline__))
  inline bool
  __is_single_threaded() noexcept
  {



    return ::__libc_single_threaded;



  }






  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __atomic_fetch_add(__mem, __val, 4); }

  inline void
  __attribute__((__always_inline__))
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __atomic_fetch_add(__mem, __val, 4); }
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/atomicity.h" 3
  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add_single(_Atomic_word* __mem, int __val)
  {
    _Atomic_word __result = *__mem;
    *__mem += __val;
    return __result;
  }

  inline void
  __attribute__((__always_inline__))
  __atomic_add_single(_Atomic_word* __mem, int __val)
  { *__mem += __val; }

  inline _Atomic_word
  __attribute__ ((__always_inline__))
  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
  {
    if (__is_single_threaded())
      return __exchange_and_add_single(__mem, __val);
    else
      return __exchange_and_add(__mem, __val);
  }

  inline void
  __attribute__ ((__always_inline__))
  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
  {
    if (__is_single_threaded())
      __atomic_add_single(__mem, __val);
    else
      __atomic_add(__mem, __val);
  }


}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++allocator.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++allocator.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functexcept.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functexcept.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




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


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

  void
  __throw_bad_array_new_length(void) __attribute__((__noreturn__));


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

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


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

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

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

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

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

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

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

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

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

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


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

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


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


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


  void
  __throw_bad_function_call() __attribute__((__noreturn__,__cold__));
# 141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functexcept.h" 3
}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
  template<typename _Tp>
    class __new_allocator
    {
    public:
      typedef _Tp value_type;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
      typedef std::true_type propagate_on_container_move_assignment;


      __attribute__((__always_inline__))
      constexpr
      __new_allocator() noexcept { }

      __attribute__((__always_inline__))
      constexpr
      __new_allocator(const __new_allocator&) noexcept { }

      template<typename _Tp1>
 __attribute__((__always_inline__))
 constexpr
 __new_allocator(const __new_allocator<_Tp1>&) noexcept { }


      __new_allocator& operator=(const __new_allocator&) = default;
# 125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
      [[__nodiscard__]] _Tp*
      allocate(size_type __n, const void* = static_cast<const void*>(0))
      {



 static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");


 if (__builtin_expect(__n > this->_M_max_size(), false))
   {


     if (__n > (std::size_t(-1) / sizeof(_Tp)))
       std::__throw_bad_array_new_length();
     std::__throw_bad_alloc();
   }


 if (alignof(_Tp) > 16UL)
   {
     std::align_val_t __al = std::align_val_t(alignof(_Tp));
     return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp),
          __al));
   }

 return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp)));
      }


      void
      deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__)))
      {







 if (alignof(_Tp) > 16UL)
   {
     __builtin_operator_delete((__p), (__n) * sizeof(_Tp),
         std::align_val_t(alignof(_Tp)));
     return;
   }

 __builtin_operator_delete((__p), (__n) * sizeof(_Tp));
      }
# 213 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
      template<typename _Up>
 friend __attribute__((__always_inline__)) constexpr bool
 operator==(const __new_allocator&, const __new_allocator<_Up>&)
 noexcept
 { return true; }
# 227 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/new_allocator.h" 3
    private:
      __attribute__((__always_inline__))
      constexpr size_type
      _M_max_size() const noexcept
      {

 return std::size_t(9223372036854775807L) / sizeof(_Tp);



      }
    };


}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++allocator.h" 2 3


namespace std
{
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++allocator.h" 3
  template<typename _Tp>
    using __allocator_base = __new_allocator<_Tp>;
}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 2 3





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
  template<>
    class allocator<void>
    {
    public:
      typedef void value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
      using propagate_on_container_move_assignment = true_type;


      using is_always_equal
 __attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal" "' instead")))
 = true_type;





      allocator() = default;
      ~allocator() = default;

      template<typename _Up>
 __attribute__((__always_inline__))
 constexpr
 allocator(const allocator<_Up>&) noexcept { }






    };
# 132 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 155 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
      using propagate_on_container_move_assignment = true_type;


      using is_always_equal
 __attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal" "' instead")))
 = true_type;





      __attribute__((__always_inline__))
      constexpr
      allocator() noexcept { }

      __attribute__((__always_inline__))
      constexpr
      allocator(const allocator& __a) noexcept
      : __allocator_base<_Tp>(__a) { }



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


      template<typename _Tp1>
 __attribute__((__always_inline__))
 constexpr
 allocator(const allocator<_Tp1>&) noexcept { }

      __attribute__((__always_inline__))

      constexpr

      ~allocator() noexcept { }


      [[nodiscard,__gnu__::__always_inline__]]
      constexpr _Tp*
      allocate(size_t __n)
      {
 if (std::__is_constant_evaluated())
   {
     if (__builtin_mul_overflow(__n, sizeof(_Tp), &__n))
       std::__throw_bad_array_new_length();
     return static_cast<_Tp*>(::operator new(__n));
   }

 return __allocator_base<_Tp>::allocate(__n, 0);
      }

      [[__gnu__::__always_inline__]]
      constexpr void
      deallocate(_Tp* __p, size_t __n)
      {
 if (std::__is_constant_evaluated())
   {
     ::operator delete(__p);
     return;
   }
 __allocator_base<_Tp>::deallocate(__p, __n);
      }


      friend __attribute__((__always_inline__)) constexpr
      bool
      operator==(const allocator&, const allocator&) noexcept
      { return true; }
# 232 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
    };






  template<typename _T1, typename _T2>
    __attribute__((__always_inline__))
    inline constexpr bool
    operator==(const allocator<_T1>&, const allocator<_T2>&)
    noexcept
    { return true; }
# 259 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocator.h" 3
  template<typename _Tp>
    class allocator<const _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<const volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };







  extern template class allocator<char>;
  extern template class allocator<wchar_t>;






}

#pragma GCC diagnostic pop
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 2 3




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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_integer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };



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

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

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

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


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



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



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

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


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

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

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

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

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

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

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

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 281 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 358 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_arithmetic
    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
    { };




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

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


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


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

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

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

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


  enum class byte : unsigned char;

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



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



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




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


  template<typename _OutputIter, typename _InputIter>
    struct __memcpyable
    {
      enum { __value = 0 };
    };


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


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

  template<typename _Tp> struct __memcpyable_integer;




  template<typename _Tp, typename _Up>
    struct __memcpyable<_Tp*, _Up*>
    {
      enum {
 __value = __memcpyable_integer<_Tp>::__width != 0
      && ((int)__memcpyable_integer<_Tp>::__width
     == (int)__memcpyable_integer<_Up>::__width)
      };
    };


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

  template<typename _Tp>
    struct __memcpyable_integer
    {
      enum {
 __width = __is_integer<_Tp>::__value ? (sizeof(_Tp) * 8) : 0
      };
    };


  template<typename _Tp>
    struct __memcpyable_integer<volatile _Tp>
    { enum { __width = 0 }; };
# 551 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 3
  __extension__
  template<>
    struct __memcpyable_integer<__int128> { enum { __width = 128 }; };
  __extension__
  template<>
    struct __memcpyable_integer<unsigned __int128> { enum { __width = 128 }; };
# 592 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 3
  template<typename _Iter1, typename _Iter2>
    struct __memcmpable
    {
      enum { __value = 0 };
    };


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

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

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







  template<typename _Tp, bool _TreatAsBytes =



 __is_byte<_Tp>::__value

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

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


  template<typename _Tp, typename _Up, bool = sizeof(_Tp) == sizeof(_Up)>
    struct __is_memcmp_ordered_with
    {
      static const bool __value = __is_memcmp_ordered<_Tp>::__value
 && __is_memcmp_ordered<_Up>::__value;
    };

  template<typename _Tp, typename _Up>
    struct __is_memcmp_ordered_with<_Tp, _Up, false>
    {
      static const bool __value = false;
    };
# 661 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cpp_type_traits.h" 3
  template<>
    struct __is_memcmp_ordered_with<std::byte, std::byte, true>
    { static constexpr bool __value = true; };

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

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



  template<typename _ValT, typename _Tp>
    constexpr bool __can_use_memchr_for_find

      = __is_byte<_ValT>::__value

   && (is_same_v<_Tp, _ValT> || is_integral_v<_Tp>);





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



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


}
}

#pragma GCC diagnostic pop
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream_insert.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream_insert.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/cxxabi_forced.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream_insert.h" 2 3


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

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);






}

#pragma GCC diagnostic pop
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 1 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/type_traits.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/type_traits.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"

extern "C++" {

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



  template<bool, typename>
    struct __enable_if
    { };

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



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

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



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

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

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

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

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

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

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

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


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



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

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

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

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

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

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

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

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


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



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

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


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




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




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

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

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

  template<>
    struct __promote<float>
    { typedef float __type; };
# 230 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/type_traits.h" 3
  template<typename... _Tp>
    using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...));



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

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

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
    using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>;
# 275 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/type_traits.h" 3
}
}

#pragma GCC diagnostic pop
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 2 3
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  namespace __detail
  {


    template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>
      using __clamp_iter_cat
 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
  }




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 130 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class reverse_iterator
    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
        typename iterator_traits<_Iterator>::value_type,
        typename iterator_traits<_Iterator>::difference_type,
        typename iterator_traits<_Iterator>::pointer,
                      typename iterator_traits<_Iterator>::reference>
    {
      template<typename _Iter>
 friend class reverse_iterator;




      template<typename _Iter>
 static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
     && convertible_to<const _Iter&, _Iterator>;


    protected:
      _Iterator current;

      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::pointer pointer;




      using iterator_concept
 = __conditional_t<random_access_iterator<_Iterator>,
     random_access_iterator_tag,
     bidirectional_iterator_tag>;
      using iterator_category
 = __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
         random_access_iterator_tag>;
      using value_type = iter_value_t<_Iterator>;
      using difference_type = iter_difference_t<_Iterator>;
      using reference = iter_reference_t<_Iterator>;
# 180 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      constexpr
      reverse_iterator()
      noexcept(noexcept(_Iterator()))
      : current()
      { }




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




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


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






      template<typename _Iter>

 requires __convertible<_Iter>

 constexpr
        reverse_iterator(const reverse_iterator<_Iter>& __x)
 noexcept(noexcept(_Iterator(__x.current)))
 : current(__x.current)
 { }


      template<typename _Iter>

 requires __convertible<_Iter>
   && assignable_from<_Iterator&, const _Iter&>

 constexpr
 reverse_iterator&
 operator=(const reverse_iterator<_Iter>& __x)
 noexcept(noexcept(current = __x.current))
 {
   current = __x.current;
   return *this;
 }





      [[__nodiscard__]]
      constexpr iterator_type
      base() const
      noexcept(noexcept(_Iterator(current)))
      { return current; }
# 257 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      [[__nodiscard__]]
      constexpr reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






      [[__nodiscard__]]
      constexpr pointer
      operator->() const

      requires is_pointer_v<_Iterator>
 || requires(const _Iterator __i) { __i.operator->(); }

      {


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






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






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






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






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






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







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






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







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






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


      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_Iterator>
      iter_move(const reverse_iterator& __i)
      noexcept(is_nothrow_copy_constructible_v<_Iterator>
        && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
      {
 auto __tmp = __i.base();
 return ranges::iter_move(--__tmp);
      }

      template<indirectly_swappable<_Iterator> _Iter2>
 friend constexpr void
 iter_swap(const reverse_iterator& __x,
    const reverse_iterator<_Iter2>& __y)
 noexcept(is_nothrow_copy_constructible_v<_Iterator>
   && is_nothrow_copy_constructible_v<_Iter2>
   && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
            --std::declval<_Iter2&>())))
 {
   auto __xtmp = __x.base();
   auto __ytmp = __y.base();
   ranges::iter_swap(--__xtmp, --__ytmp);
 }


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

      template<typename _Tp>
 static constexpr pointer
 _S_to_pointer(_Tp __t)
        { return __t.operator->(); }
    };
# 526 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator!=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
    { return __x.base() != __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator<(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
    { return __x.base() > __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator>(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
    { return __x.base() < __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator<=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
    { return __x.base() >= __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator>=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
    { return __x.base() <= __y.base(); }

  template<typename _IteratorL,
    three_way_comparable_with<_IteratorL> _IteratorR>
    [[nodiscard]]
    constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
    operator<=>(const reverse_iterator<_IteratorL>& __x,
  const reverse_iterator<_IteratorR>& __y)
    { return __y.base() <=> __x.base(); }




  template<typename _Iterator>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

  template<three_way_comparable _Iterator>
    [[nodiscard]]
    constexpr compare_three_way_result_t<_Iterator, _Iterator>
    operator<=>(const reverse_iterator<_Iterator>& __x,
  const reverse_iterator<_Iterator>& __y)
    { return __y.base() <=> __x.base(); }
# 617 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr auto
    operator-(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    -> decltype(__y.base() - __x.base())
    { return __y.base() - __x.base(); }


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



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





  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Iterator>
    make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }


  template<typename _Iterator1, typename _Iterator2>
    requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
    inline constexpr bool
    disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
          reverse_iterator<_Iterator2>> = true;



  template<typename _Iterator>
    struct __is_move_iterator<reverse_iterator<_Iterator> >
      : __is_move_iterator<_Iterator>
    { };
# 676 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    class back_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;

      using difference_type = ptrdiff_t;



      explicit constexpr
      back_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 714 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      constexpr
      back_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_back(__value);
 return *this;
      }

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



      [[__nodiscard__]] constexpr
      back_insert_iterator&
      operator*()
      { return *this; }


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


      constexpr
      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 761 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    [[__nodiscard__]] constexpr
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 777 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    class front_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;

      using difference_type = ptrdiff_t;



      explicit constexpr
      front_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 815 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      constexpr
      front_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_front(__value);
 return *this;
      }

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



      [[__nodiscard__]] constexpr
      front_insert_iterator&
      operator*()
      { return *this; }


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


      constexpr
      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 862 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    [[__nodiscard__]] constexpr
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 882 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    class insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {

      using _Iter = std::__detail::__range_iter_t<_Container>;



    protected:
      _Container* container;
      _Iter iter;

    public:

      typedef _Container container_type;


      using difference_type = ptrdiff_t;






      constexpr
      insert_iterator(_Container& __x, _Iter __i)
      : container(std::__addressof(__x)), iter(__i) {}
# 943 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      constexpr
      insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }

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



      [[__nodiscard__]] constexpr
      insert_iterator&
      operator*()
      { return *this; }


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


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

#pragma GCC diagnostic pop
# 996 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Container>
    [[nodiscard]]
    constexpr insert_iterator<_Container>
    inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
    { return insert_iterator<_Container>(__x, __i); }
# 1012 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 1025 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;


      using iterator_concept = std::__detail::__iter_concept<_Iterator>;


      __attribute__((__always_inline__))
      constexpr
      __normal_iterator() noexcept
      : _M_current() { }

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




      template<typename _Iter> requires std::is_convertible_v<_Iter, _Iterator>



 [[__gnu__::__always_inline__]]
 constexpr
 __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 noexcept
# 1082 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
        : _M_current(__i.base()) { }



      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      reference
      operator*() const noexcept
      { return *_M_current; }

      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      pointer
      operator->() const noexcept
      { return _M_current; }

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

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



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

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



      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      reference
      operator[](difference_type __n) const noexcept
      { return _M_current[__n]; }

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

      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      __normal_iterator
      operator+(difference_type __n) const noexcept
      { return __normal_iterator(_M_current + __n); }

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

      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      __normal_iterator
      operator-(difference_type __n) const noexcept
      { return __normal_iterator(_M_current - __n); }

      [[__nodiscard__]] __attribute__((__always_inline__))
      constexpr
      const _Iterator&
      base() const noexcept
      { return _M_current; }
    };
# 1178 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept(noexcept(__lhs.base() == __rhs.base()))
    requires requires {
      { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
    }
    { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
    operator<=>(const __normal_iterator<_IteratorL, _Container>& __lhs,
  const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
    { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }

  template<typename _Iterator, typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept(noexcept(__lhs.base() == __rhs.base()))
    requires requires {
      { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
    }
    { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr std::__detail::__synth3way_t<_Iterator>
    operator<=>(const __normal_iterator<_Iterator, _Container>& __lhs,
  const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
    { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
# 1319 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>


    [[__nodiscard__, __gnu__::__always_inline__]]
    constexpr auto
    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
    -> decltype(__lhs.base() - __rhs.base())





    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[__nodiscard__]] __attribute__((__always_inline__)) constexpr
    inline typename __normal_iterator<_Iterator, _Container>::difference_type
    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[__nodiscard__]] __attribute__((__always_inline__)) constexpr
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    noexcept
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }


}

namespace std __attribute__ ((__visibility__ ("default")))
{
# 1365 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<semiregular _Sent>
    class move_sentinel
    {
    public:
      constexpr
      move_sentinel()
      noexcept(is_nothrow_default_constructible_v<_Sent>)
      : _M_last() { }

      constexpr explicit
      move_sentinel(_Sent __s)
      noexcept(is_nothrow_move_constructible_v<_Sent>)
      : _M_last(std::move(__s)) { }

      template<typename _S2> requires convertible_to<const _S2&, _Sent>
 constexpr
 move_sentinel(const move_sentinel<_S2>& __s)
 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
 : _M_last(__s.base())
 { }

      template<typename _S2> requires assignable_from<_Sent&, const _S2&>
 constexpr move_sentinel&
 operator=(const move_sentinel<_S2>& __s)
 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
 {
   _M_last = __s.base();
   return *this;
 }

      [[nodiscard]]
      constexpr _Sent
      base() const
      noexcept(is_nothrow_copy_constructible_v<_Sent>)
      { return _M_last; }

    private:
      _Sent _M_last;
    };


  namespace __detail
  {
    template<typename _Iterator>
      struct __move_iter_cat
      { };

    template<typename _Iterator>
      requires requires { typename __iter_category_t<_Iterator>; }
      struct __move_iter_cat<_Iterator>
      {
 using iterator_category
   = __clamp_iter_cat<__iter_category_t<_Iterator>,
        random_access_iterator_tag>;
      };
  }
# 1434 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class move_iterator

      : public __detail::__move_iter_cat<_Iterator>

    {
      _Iterator _M_current;

      using __traits_type = iterator_traits<_Iterator>;




      template<typename _Iter2>
 friend class move_iterator;




      template<typename _Iter2>
 static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
     && convertible_to<const _Iter2&, _Iterator>;



      static auto
      _S_iter_concept()
      {
 if constexpr (random_access_iterator<_Iterator>)
   return random_access_iterator_tag{};
 else if constexpr (bidirectional_iterator<_Iterator>)
   return bidirectional_iterator_tag{};
 else if constexpr (forward_iterator<_Iterator>)
   return forward_iterator_tag{};
 else
   return input_iterator_tag{};
      }


    public:
      using iterator_type = _Iterator;


      using iterator_concept = decltype(_S_iter_concept());


      using value_type = iter_value_t<_Iterator>;
      using difference_type = iter_difference_t<_Iterator>;
      using pointer = _Iterator;
      using reference = iter_rvalue_reference_t<_Iterator>;
# 1498 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
      constexpr
      move_iterator()
      : _M_current() { }

      explicit constexpr
      move_iterator(iterator_type __i)
      : _M_current(std::move(__i)) { }

      template<typename _Iter>

 requires __convertible<_Iter>

 constexpr
 move_iterator(const move_iterator<_Iter>& __i)
 : _M_current(__i._M_current) { }

      template<typename _Iter>

 requires __convertible<_Iter>
   && assignable_from<_Iterator&, const _Iter&>

 constexpr
 move_iterator& operator=(const move_iterator<_Iter>& __i)
 {
   _M_current = __i._M_current;
   return *this;
 }







      [[nodiscard]]
      constexpr const iterator_type&
      base() const & noexcept
      { return _M_current; }

      [[nodiscard]]
      constexpr iterator_type
      base() &&
      { return std::move(_M_current); }


      [[__nodiscard__]]
      constexpr reference
      operator*() const

      { return ranges::iter_move(_M_current); }




      [[__nodiscard__]]
      constexpr pointer
      operator->() const
      { return _M_current; }

      constexpr move_iterator&
      operator++()
      {
 ++_M_current;
 return *this;
      }

      constexpr move_iterator
      operator++(int)
      {
 move_iterator __tmp = *this;
 ++_M_current;
 return __tmp;
      }


      constexpr void
      operator++(int) requires (!forward_iterator<_Iterator>)
      { ++_M_current; }


      constexpr move_iterator&
      operator--()
      {
 --_M_current;
 return *this;
      }

      constexpr move_iterator
      operator--(int)
      {
 move_iterator __tmp = *this;
 --_M_current;
 return __tmp;
      }

      [[__nodiscard__]]
      constexpr move_iterator
      operator+(difference_type __n) const
      { return move_iterator(_M_current + __n); }

      constexpr move_iterator&
      operator+=(difference_type __n)
      {
 _M_current += __n;
 return *this;
      }

      [[__nodiscard__]]
      constexpr move_iterator
      operator-(difference_type __n) const
      { return move_iterator(_M_current - __n); }

      constexpr move_iterator&
      operator-=(difference_type __n)
      {
 _M_current -= __n;
 return *this;
      }

      [[__nodiscard__]]
      constexpr reference
      operator[](difference_type __n) const

      { return ranges::iter_move(_M_current + __n); }





      template<sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr bool
 operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
 { return __x.base() == __y.base(); }

      template<sized_sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr iter_difference_t<_Iterator>
 operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
 { return __x.base() - __y.base(); }

      template<sized_sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr iter_difference_t<_Iterator>
 operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
 { return __x.base() - __y.base(); }

      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_Iterator>
      iter_move(const move_iterator& __i)
      noexcept(noexcept(ranges::iter_move(__i._M_current)))
      { return ranges::iter_move(__i._M_current); }

      template<indirectly_swappable<_Iterator> _Iter2>
 friend constexpr void
 iter_swap(const move_iterator& __x, const move_iterator<_Iter2>& __y)
 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
 { return ranges::iter_swap(__x._M_current, __y._M_current); }

    };

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator==(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }

    { return __x.base() == __y.base(); }


  template<typename _IteratorL,
    three_way_comparable_with<_IteratorL> _IteratorR>
    [[__nodiscard__]]
    constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
    operator<=>(const move_iterator<_IteratorL>& __x,
  const move_iterator<_IteratorR>& __y)
    { return __x.base() <=> __y.base(); }
# 1686 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator<(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }

    { return __x.base() < __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator<=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }

    { return !(__y < __x); }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator>(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)

    requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }

    { return __y < __x; }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator>=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }

    { return !(__x < __y); }




  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr bool
    operator==(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)

    { return __x.base() == __y.base(); }


  template<three_way_comparable _Iterator>
    [[__nodiscard__]]
    constexpr compare_three_way_result_t<_Iterator>
    operator<=>(const move_iterator<_Iterator>& __x,
  const move_iterator<_Iterator>& __y)
    { return __x.base() <=> __y.base(); }
# 1782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr auto
    operator-(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)
    -> decltype(__x.base() - __y.base())
    { return __x.base() - __y.base(); }

  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr move_iterator<_Iterator>
    operator+(typename move_iterator<_Iterator>::difference_type __n,
       const move_iterator<_Iterator>& __x)

    requires requires { { __x.base() + __n } -> same_as<_Iterator>; }

    { return __x + __n; }

  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr move_iterator<_Iterator>
    make_move_iterator(_Iterator __i)
    { return move_iterator<_Iterator>(std::move(__i)); }

  template<typename _Iterator, typename _ReturnType
    = __conditional_t<__move_if_noexcept_cond
      <typename iterator_traits<_Iterator>::value_type>::value,
  _Iterator, move_iterator<_Iterator>>>
    [[__nodiscard__]]
    constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Iterator __i)
    { return _ReturnType(__i); }



  template<typename _Tp, typename _ReturnType
    = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
        const _Tp*, move_iterator<_Tp*>>>
    [[__nodiscard__]]
    constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Tp* __i)
    { return _ReturnType(__i); }

  template<typename _Iterator>
    struct __is_move_iterator<move_iterator<_Iterator> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 1843 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Iterator1, typename _Iterator2>
    requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
    inline constexpr bool
    disable_sized_sentinel_for<move_iterator<_Iterator1>,
          move_iterator<_Iterator2>> = true;




  namespace __detail
  {
    template<typename _It>
      concept __common_iter_has_arrow = indirectly_readable<const _It>
 && (requires(const _It& __it) { __it.operator->(); }
     || is_reference_v<iter_reference_t<_It>>
     || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);

    template<typename _It>
      concept __common_iter_use_postfix_proxy
 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
   && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
   && move_constructible<iter_value_t<_It>>;
  }



  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    requires (!same_as<_It, _Sent>) && copyable<_It>
  class common_iterator
  {
    template<typename _Tp, typename _Up>
      static constexpr bool
      _S_noexcept1()
      {
 if constexpr (is_trivially_default_constructible_v<_Tp>)
   return is_nothrow_assignable_v<_Tp&, _Up>;
 else
   return is_nothrow_constructible_v<_Tp, _Up>;
      }

    template<typename _It2, typename _Sent2>
      static constexpr bool
      _S_noexcept()
      { return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }

    class __arrow_proxy
    {
      iter_value_t<_It> _M_keep;

      constexpr
      __arrow_proxy(iter_reference_t<_It>&& __x)
      : _M_keep(std::move(__x)) { }

      friend class common_iterator;

    public:
      constexpr const iter_value_t<_It>*
      operator->() const noexcept
      { return std::__addressof(_M_keep); }
    };

    class __postfix_proxy
    {
      iter_value_t<_It> _M_keep;

      constexpr
      __postfix_proxy(iter_reference_t<_It>&& __x)
      : _M_keep(std::forward<iter_reference_t<_It>>(__x)) { }

      friend class common_iterator;

    public:
      constexpr const iter_value_t<_It>&
      operator*() const noexcept
      { return _M_keep; }
    };

  public:
    constexpr
    common_iterator()
    noexcept(is_nothrow_default_constructible_v<_It>)
    requires default_initializable<_It>
    : _M_it(), _M_index(0)
    { }

    constexpr
    common_iterator(_It __i)
    noexcept(is_nothrow_move_constructible_v<_It>)
    : _M_it(std::move(__i)), _M_index(0)
    { }

    constexpr
    common_iterator(_Sent __s)
    noexcept(is_nothrow_move_constructible_v<_Sent>)
    : _M_sent(std::move(__s)), _M_index(1)
    { }

    template<typename _It2, typename _Sent2>
      requires convertible_to<const _It2&, _It>
 && convertible_to<const _Sent2&, _Sent>
      constexpr
      common_iterator(const common_iterator<_It2, _Sent2>& __x)
      noexcept(_S_noexcept<const _It2&, const _Sent2&>())
      : _M_valueless(), _M_index(__x._M_index)
      {
 do { if (std::__is_constant_evaluated() && !bool(__x._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
 if (_M_index == 0)
   {
     if constexpr (is_trivially_default_constructible_v<_It>)
       _M_it = std::move(__x._M_it);
     else
       std::construct_at(std::__addressof(_M_it), __x._M_it);
   }
 else if (_M_index == 1)
   {
     if constexpr (is_trivially_default_constructible_v<_Sent>)
       _M_sent = std::move(__x._M_sent);
     else
       std::construct_at(std::__addressof(_M_sent), __x._M_sent);
   }
      }

    common_iterator(const common_iterator&) = default;

    constexpr
    common_iterator(const common_iterator& __x)
    noexcept(_S_noexcept<const _It&, const _Sent&>())
    requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
    : _M_valueless(), _M_index(__x._M_index)
    {
      if (_M_index == 0)
 {
   if constexpr (is_trivially_default_constructible_v<_It>)
     _M_it = __x._M_it;
   else
     std::construct_at(std::__addressof(_M_it), __x._M_it);
 }
      else if (_M_index == 1)
 {
   if constexpr (is_trivially_default_constructible_v<_Sent>)
     _M_sent = __x._M_sent;
   else
     std::construct_at(std::__addressof(_M_sent), __x._M_sent);
 }
    }

    common_iterator(common_iterator&&) = default;

    constexpr
    common_iterator(common_iterator&& __x)
    noexcept(_S_noexcept<_It, _Sent>())
    requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
    : _M_valueless(), _M_index(__x._M_index)
    {
      if (_M_index == 0)
 {
   if constexpr (is_trivially_default_constructible_v<_It>)
     _M_it = std::move(__x._M_it);
   else
     std::construct_at(std::__addressof(_M_it), std::move(__x._M_it));
 }
      else if (_M_index == 1)
 {
   if constexpr (is_trivially_default_constructible_v<_Sent>)
     _M_sent = std::move(__x._M_sent);
   else
     std::construct_at(std::__addressof(_M_sent),
         std::move(__x._M_sent));
 }
    }

    constexpr common_iterator&
    operator=(const common_iterator&) = default;

    constexpr common_iterator&
    operator=(const common_iterator& __x)
    noexcept(is_nothrow_copy_assignable_v<_It>
      && is_nothrow_copy_assignable_v<_Sent>
      && is_nothrow_copy_constructible_v<_It>
      && is_nothrow_copy_constructible_v<_Sent>)
    requires (!is_trivially_copy_assignable_v<_It>
  || !is_trivially_copy_assignable_v<_Sent>)
    {
      _M_assign(__x);
      return *this;
    }

    constexpr common_iterator&
    operator=(common_iterator&&) = default;

    constexpr common_iterator&
    operator=(common_iterator&& __x)
    noexcept(is_nothrow_move_assignable_v<_It>
      && is_nothrow_move_assignable_v<_Sent>
      && is_nothrow_move_constructible_v<_It>
      && is_nothrow_move_constructible_v<_Sent>)
    requires (!is_trivially_move_assignable_v<_It>
  || !is_trivially_move_assignable_v<_Sent>)
    {
      _M_assign(std::move(__x));
      return *this;
    }

    template<typename _It2, typename _Sent2>
      requires convertible_to<const _It2&, _It>
 && convertible_to<const _Sent2&, _Sent>
 && assignable_from<_It&, const _It2&>
 && assignable_from<_Sent&, const _Sent2&>
      constexpr common_iterator&
      operator=(const common_iterator<_It2, _Sent2>& __x)
      noexcept(is_nothrow_constructible_v<_It, const _It2&>
        && is_nothrow_constructible_v<_Sent, const _Sent2&>
        && is_nothrow_assignable_v<_It&, const _It2&>
        && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
      {
 do { if (std::__is_constant_evaluated() && !bool(__x._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
 _M_assign(__x);
 return *this;
      }


    ~common_iterator() = default;

    constexpr
    ~common_iterator()
      requires (!is_trivially_destructible_v<_It>
    || !is_trivially_destructible_v<_Sent>)




    {
      if (_M_index == 0)
 _M_it.~_It();
      else if (_M_index == 1)
 _M_sent.~_Sent();
    }

    [[nodiscard]]
    constexpr decltype(auto)
    operator*()
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      return *_M_it;
    }

    [[nodiscard]]
    constexpr decltype(auto)
    operator*() const requires __detail::__dereferenceable<const _It>
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      return *_M_it;
    }

    [[nodiscard]]
    constexpr auto
    operator->() const requires __detail::__common_iter_has_arrow<_It>
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
 return _M_it;
      else if constexpr (is_reference_v<iter_reference_t<_It>>)
 {
   auto&& __tmp = *_M_it;
   return std::__addressof(__tmp);
 }
      else
 return __arrow_proxy{*_M_it};
    }

    constexpr common_iterator&
    operator++()
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      ++_M_it;
      return *this;
    }

    constexpr decltype(auto)
    operator++(int)
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      if constexpr (forward_iterator<_It>)
 {
   common_iterator __tmp = *this;
   ++*this;
   return __tmp;
 }
      else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
 return _M_it++;
      else
 {
   __postfix_proxy __p(**this);
   ++*this;
   return __p;
 }
    }

    template<typename _It2, sentinel_for<_It> _Sent2>
      requires sentinel_for<_Sent, _It2>
      friend constexpr bool
      operator== [[nodiscard]] (const common_iterator& __x,
    const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0000:
   case 0b0101:
     return true;
   case 0b0001:
     return __x._M_it == __y._M_sent;
   case 0b0100:
     return __x._M_sent == __y._M_it;
   default:
     do { if (std::__is_constant_evaluated() && !bool(__x._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated() && !bool(__y._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    template<typename _It2, sentinel_for<_It> _Sent2>
      requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
      friend constexpr bool
      operator== [[nodiscard]] (const common_iterator& __x,
    const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0101:
     return true;
   case 0b0000:
     return __x._M_it == __y._M_it;
   case 0b0001:
     return __x._M_it == __y._M_sent;
   case 0b0100:
     return __x._M_sent == __y._M_it;
   default:
     do { if (std::__is_constant_evaluated() && !bool(__x._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated() && !bool(__y._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
      requires sized_sentinel_for<_Sent, _It2>
      friend constexpr iter_difference_t<_It2>
      operator- [[nodiscard]] (const common_iterator& __x,
          const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0101:
     return 0;
   case 0b0000:
     return __x._M_it - __y._M_it;
   case 0b0001:
     return __x._M_it - __y._M_sent;
   case 0b0100:
     return __x._M_sent - __y._M_it;
   default:
     do { if (std::__is_constant_evaluated() && !bool(__x._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated() && !bool(__y._M_has_value())) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    [[nodiscard]]
    friend constexpr iter_rvalue_reference_t<_It>
    iter_move(const common_iterator& __i)
    noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
    requires input_iterator<_It>
    {
      do { if (std::__is_constant_evaluated() && !bool(__i._M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
      return ranges::iter_move(__i._M_it);
    }

    template<indirectly_swappable<_It> _It2, typename _Sent2>
      friend constexpr void
      iter_swap(const common_iterator& __x,
  const common_iterator<_It2, _Sent2>& __y)
      noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
       std::declval<const _It2&>())))
      {
 do { if (std::__is_constant_evaluated() && !bool(__x._M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__y._M_index == 0)) std::__glibcxx_assert_fail(); } while (false);
 return ranges::iter_swap(__x._M_it, __y._M_it);
      }

  private:
    template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
      requires (!same_as<_It2, _Sent2>) && copyable<_It2>
      friend class common_iterator;

    constexpr bool
    _M_has_value() const noexcept { return _M_index != _S_valueless; }

    template<typename _CIt>
      constexpr void
      _M_assign(_CIt&& __x)
      {
 if (_M_index == __x._M_index)
   {
     if (_M_index == 0)
       _M_it = std::forward<_CIt>(__x)._M_it;
     else if (_M_index == 1)
       _M_sent = std::forward<_CIt>(__x)._M_sent;
   }
 else
   {
     if (_M_index == 0)
       _M_it.~_It();
     else if (_M_index == 1)
       _M_sent.~_Sent();
     _M_index = _S_valueless;

     if (__x._M_index == 0)
       std::construct_at(std::__addressof(_M_it),
    std::forward<_CIt>(__x)._M_it);
     else if (__x._M_index == 1)
       std::construct_at(std::__addressof(_M_sent),
    std::forward<_CIt>(__x)._M_sent);
     _M_index = __x._M_index;
   }
      }

    union
    {
      _It _M_it;
      _Sent _M_sent;
      unsigned char _M_valueless;
    };
    unsigned char _M_index;

    static constexpr unsigned char _S_valueless{2};
  };

  template<typename _It, typename _Sent>
    struct incrementable_traits<common_iterator<_It, _Sent>>
    {
      using difference_type = iter_difference_t<_It>;
    };

  template<input_iterator _It, typename _Sent>
    struct iterator_traits<common_iterator<_It, _Sent>>
    {
    private:
      template<typename _Iter>
 struct __ptr
 {
   using type = void;
 };

      template<typename _Iter>
 requires __detail::__common_iter_has_arrow<_Iter>
 struct __ptr<_Iter>
 {
   using _CIter = common_iterator<_Iter, _Sent>;
   using type = decltype(std::declval<const _CIter&>().operator->());
 };

      static auto
      _S_iter_cat()
      {
 if constexpr (requires { requires derived_from<__iter_category_t<_It>,
             forward_iterator_tag>; })
   return forward_iterator_tag{};
 else
   return input_iterator_tag{};
      }

    public:
      using iterator_concept = __conditional_t<forward_iterator<_It>,
            forward_iterator_tag,
            input_iterator_tag>;
      using iterator_category = decltype(_S_iter_cat());
      using value_type = iter_value_t<_It>;
      using difference_type = iter_difference_t<_It>;
      using pointer = typename __ptr<_It>::type;
      using reference = iter_reference_t<_It>;
    };




  namespace __detail
  {
    template<typename _It>
      struct __counted_iter_value_type
      { };

    template<indirectly_readable _It>
      struct __counted_iter_value_type<_It>
      { using value_type = iter_value_t<_It>; };

    template<typename _It>
      struct __counted_iter_concept
      { };

    template<typename _It>
      requires requires { typename _It::iterator_concept; }
      struct __counted_iter_concept<_It>
      { using iterator_concept = typename _It::iterator_concept; };

    template<typename _It>
      struct __counted_iter_cat
      { };

    template<typename _It>
      requires requires { typename _It::iterator_category; }
      struct __counted_iter_cat<_It>
      { using iterator_category = typename _It::iterator_category; };
  }



  template<input_or_output_iterator _It>
    class counted_iterator
      : public __detail::__counted_iter_value_type<_It>,
 public __detail::__counted_iter_concept<_It>,
 public __detail::__counted_iter_cat<_It>
    {
    public:
      using iterator_type = _It;

      using difference_type = iter_difference_t<_It>;



      constexpr counted_iterator() requires default_initializable<_It> = default;

      constexpr
      counted_iterator(_It __i, iter_difference_t<_It> __n)
      : _M_current(std::move(__i)), _M_length(__n)
      { do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false); }

      template<typename _It2>
 requires convertible_to<const _It2&, _It>
 constexpr
 counted_iterator(const counted_iterator<_It2>& __x)
 : _M_current(__x._M_current), _M_length(__x._M_length)
 { }

      template<typename _It2>
 requires assignable_from<_It&, const _It2&>
 constexpr counted_iterator&
 operator=(const counted_iterator<_It2>& __x)
 {
   _M_current = __x._M_current;
   _M_length = __x._M_length;
   return *this;
 }

      [[nodiscard]]
      constexpr const _It&
      base() const & noexcept
      { return _M_current; }

      [[nodiscard]]
      constexpr _It
      base() &&
      noexcept(is_nothrow_move_constructible_v<_It>)
      { return std::move(_M_current); }

      [[nodiscard]]
      constexpr iter_difference_t<_It>
      count() const noexcept { return _M_length; }

      [[nodiscard]]
      constexpr decltype(auto)
      operator*()
      noexcept(noexcept(*_M_current))
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_current;
      }

      [[nodiscard]]
      constexpr decltype(auto)
      operator*() const
      noexcept(noexcept(*_M_current))
      requires __detail::__dereferenceable<const _It>
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_current;
      }

      [[nodiscard]]
      constexpr auto
      operator->() const noexcept
      requires contiguous_iterator<_It>
      { return std::to_address(_M_current); }

      constexpr counted_iterator&
      operator++()
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
 ++_M_current;
 --_M_length;
 return *this;
      }

      constexpr decltype(auto)
      operator++(int)
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
 --_M_length;
 try
   {
     return _M_current++;
   } catch(...) {
     ++_M_length;
     throw;
   }
      }

      constexpr counted_iterator
      operator++(int) requires forward_iterator<_It>
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr counted_iterator&
      operator--() requires bidirectional_iterator<_It>
      {
 --_M_current;
 ++_M_length;
 return *this;
      }

      constexpr counted_iterator
      operator--(int) requires bidirectional_iterator<_It>
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      [[nodiscard]]
      constexpr counted_iterator
      operator+(iter_difference_t<_It> __n) const
 requires random_access_iterator<_It>
      { return counted_iterator(_M_current + __n, _M_length - __n); }

      [[nodiscard]]
      friend constexpr counted_iterator
      operator+(iter_difference_t<_It> __n, const counted_iterator& __x)
      requires random_access_iterator<_It>
      { return __x + __n; }

      constexpr counted_iterator&
      operator+=(iter_difference_t<_It> __n)
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated() && !bool(__n <= _M_length)) std::__glibcxx_assert_fail(); } while (false);
 _M_current += __n;
 _M_length -= __n;
 return *this;
      }

      [[nodiscard]]
      constexpr counted_iterator
      operator-(iter_difference_t<_It> __n) const
      requires random_access_iterator<_It>
      { return counted_iterator(_M_current - __n, _M_length + __n); }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr iter_difference_t<_It2>
 operator-(const counted_iterator& __x,
    const counted_iterator<_It2>& __y)
 { return __y._M_length - __x._M_length; }

      [[nodiscard]]
      friend constexpr iter_difference_t<_It>
      operator-(const counted_iterator& __x, default_sentinel_t)
      { return -__x._M_length; }

      [[nodiscard]]
      friend constexpr iter_difference_t<_It>
      operator-(default_sentinel_t, const counted_iterator& __y)
      { return __y._M_length; }

      constexpr counted_iterator&
      operator-=(iter_difference_t<_It> __n)
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated() && !bool(-__n <= _M_length)) std::__glibcxx_assert_fail(); } while (false);
 _M_current -= __n;
 _M_length += __n;
 return *this;
      }

      [[nodiscard]]
      constexpr decltype(auto)
      operator[](iter_difference_t<_It> __n) const
      noexcept(noexcept(_M_current[__n]))
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < _M_length)) std::__glibcxx_assert_fail(); } while (false);
 return _M_current[__n];
      }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr bool
 operator==(const counted_iterator& __x,
     const counted_iterator<_It2>& __y)
 { return __x._M_length == __y._M_length; }

      [[nodiscard]]
      friend constexpr bool
      operator==(const counted_iterator& __x, default_sentinel_t)
      { return __x._M_length == 0; }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr strong_ordering
 operator<=>(const counted_iterator& __x,
      const counted_iterator<_It2>& __y)
 { return __y._M_length <=> __x._M_length; }

      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_It>
      iter_move(const counted_iterator& __i)
      noexcept(noexcept(ranges::iter_move(__i._M_current)))
      requires input_iterator<_It>
      {
 do { if (std::__is_constant_evaluated() && !bool(__i._M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
 return ranges::iter_move(__i._M_current);
      }

      template<indirectly_swappable<_It> _It2>
 friend constexpr void
 iter_swap(const counted_iterator& __x,
    const counted_iterator<_It2>& __y)
 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
 {
   do { if (std::__is_constant_evaluated() && !bool(__x._M_length > 0 && __y._M_length > 0)) std::__glibcxx_assert_fail(); } while (false);
   ranges::iter_swap(__x._M_current, __y._M_current);
 }

    private:
      template<input_or_output_iterator _It2> friend class counted_iterator;

      _It _M_current = _It();
      iter_difference_t<_It> _M_length = 0;
    };

  template<input_iterator _It>
    requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
    struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
    {
      using pointer = __conditional_t<contiguous_iterator<_It>,
          add_pointer_t<iter_reference_t<_It>>,
          void>;
    };
# 2981 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
}

namespace __gnu_debug
{
  template<typename _Iterator, typename _Sequence, typename _Category>
    class _Safe_iterator;
}

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





  template<typename _Iterator, typename _Container>
    [[__nodiscard__]] __attribute__((__always_inline__))
    constexpr
    inline _Iterator
    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it.base(); }


  template<typename _Iterator>
    [[__nodiscard__]] __attribute__((__always_inline__))
    constexpr
    inline _Iterator
    __niter_base(_Iterator __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it; }
# 3027 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_iterator.h" 3
  template<typename _Ite, typename _Seq>
    constexpr
    decltype(std::__niter_base(std::declval<_Ite>()))
    __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq,
   std::random_access_iterator_tag>&)
    noexcept(std::is_nothrow_copy_constructible<_Ite>::value);



  template<typename _Iterator>
    constexpr
    inline 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>
    constexpr
    inline 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>
    constexpr
    inline auto
    __miter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
    { return __make_reverse_iterator(__miter_base(__it.base())); }

  template<typename _Iterator>
    constexpr
    inline auto
    __miter_base(move_iterator<_Iterator> __it)
    -> decltype(__miter_base(__it.base()))
    { return __miter_base(__it.base()); }






  template<typename _From, typename _To>
    [[__nodiscard__]]
    constexpr
    inline _From
    __niter_wrap(_From __from, _To __res)
    { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); }


  template<typename _Iterator>
    [[__nodiscard__]] __attribute__((__always_inline__))
    constexpr
    inline _Iterator
    __niter_wrap(const _Iterator&, _Iterator __res)
    { return __res; }






  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<const __iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>>;



}
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 116 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    struct unary_function
    {

      typedef _Arg argument_type;


      typedef _Result result_type;
    } __attribute__ ((__deprecated__));





  template<typename _Arg1, typename _Arg2, typename _Result>
    struct binary_function
    {

      typedef _Arg1 first_argument_type;


      typedef _Arg2 second_argument_type;


      typedef _Result result_type;
    } __attribute__ ((__deprecated__));
# 157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  struct __is_transparent;

  template<typename _Tp = void>
    struct plus;

  template<typename _Tp = void>
    struct minus;

  template<typename _Tp = void>
    struct multiplies;

  template<typename _Tp = void>
    struct divides;

  template<typename _Tp = void>
    struct modulus;

  template<typename _Tp = void>
    struct negate;



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


  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {

      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template<typename _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template<typename _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template<typename _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template<typename _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
#pragma GCC diagnostic pop


  template<>
    struct plus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct minus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct multiplies<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct divides<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct modulus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct negate<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(-std::forward<_Tp>(__t)))
 -> decltype(-std::forward<_Tp>(__t))
 { return -std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };
# 346 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct equal_to;

  template<typename _Tp = void>
    struct not_equal_to;

  template<typename _Tp = void>
    struct greater;

  template<typename _Tp = void>
    struct less;

  template<typename _Tp = void>
    struct greater_equal;

  template<typename _Tp = void>
    struct less_equal;


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


  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template<typename _Tp>
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template<typename _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template<typename _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template<typename _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };


  template<typename _Tp>
    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x > __y;

 return (long unsigned int)__x > (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x < __y;

 return (long unsigned int)__x < (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x >= __y;

 return (long unsigned int)__x >= (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x <= __y;

 return (long unsigned int)__x <= (long unsigned int)__y;
      }
    };
#pragma GCC diagnostic pop



  template<>
    struct equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct not_equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct greater<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct greater_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };
# 778 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct logical_and;

  template<typename _Tp = void>
    struct logical_or;

  template<typename _Tp = void>
    struct logical_not;


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


  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template<typename _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };
#pragma GCC diagnostic pop



  template<>
    struct logical_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(!std::forward<_Tp>(__t)))
 -> decltype(!std::forward<_Tp>(__t))
 { return !std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };




  template<typename _Tp = void>
    struct bit_and;

  template<typename _Tp = void>
    struct bit_or;

  template<typename _Tp = void>
    struct bit_xor;

  template<typename _Tp = void>
    struct bit_not;


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



  template<typename _Tp>
    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
    };

  template<typename _Tp>
    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
    };

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };

  template<typename _Tp>
    struct bit_not : public unary_function<_Tp, _Tp>
    {
    constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return ~__x; }
    };
#pragma GCC diagnostic pop


  template <>
    struct bit_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_xor<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(~std::forward<_Tp>(__t)))
 -> decltype(~std::forward<_Tp>(__t))
 { return ~std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 1020 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Predicate>
    class [[__deprecated__]] unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>
    __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
    constexpr
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template<typename _Predicate>
    class [[__deprecated__]] binary_negate
    : public binary_function<typename _Predicate::first_argument_type,
        typename _Predicate::second_argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::first_argument_type& __x,
   const typename _Predicate::second_argument_type& __y) const
      { return !_M_pred(__x, __y); }
    };


  template<typename _Predicate>
    __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
    constexpr
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 1101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    class pointer_to_unary_function : public unary_function<_Arg, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    } __attribute__ ((__deprecated__));


  template<typename _Arg, typename _Result>
    __attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
    inline pointer_to_unary_function<_Arg, _Result>
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function<_Arg, _Result>(__x); }


  template<typename _Arg1, typename _Arg2, typename _Result>
    class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    } __attribute__ ((__deprecated__));


  template<typename _Arg1, typename _Arg2, typename _Result>
    __attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }


  template<typename _Tp>
    struct _Identity
    : public unary_function<_Tp, _Tp>
    {
      _Tp&
      operator()(_Tp& __x) const
      { return __x; }

      const _Tp&
      operator()(const _Tp& __x) const
      { return __x; }
    };


  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };

  template<typename _Pair>
    struct _Select1st
    : public unary_function<_Pair, typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

      const typename _Pair::first_type&
      operator()(const _Pair& __x) const
      { return __x.first; }


      template<typename _Pair2>
        typename _Pair2::first_type&
        operator()(_Pair2& __x) const
        { return __x.first; }

      template<typename _Pair2>
        const typename _Pair2::first_type&
        operator()(const _Pair2& __x) const
        { return __x.first; }

    };

  template<typename _Pair>
    struct _Select2nd
    : public unary_function<_Pair, typename _Pair::second_type>
    {
      typename _Pair::second_type&
      operator()(_Pair& __x) const
      { return __x.second; }

      const typename _Pair::second_type&
      operator()(const _Pair& __x) const
      { return __x.second; }
    };
# 1228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 3
  template<typename _Ret, typename _Tp>
    class mem_fun_t : public unary_function<_Tp*, _Ret>
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    } __attribute__ ((__deprecated__));



  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
#pragma GCC diagnostic pop




  template<typename _Func, typename _SfinaeType, typename = __void_t<>>
    struct __has_is_transparent
    { };

  template<typename _Func, typename _SfinaeType>
    struct __has_is_transparent<_Func, _SfinaeType,
    __void_t<typename _Func::is_transparent>>
    { typedef void type; };

  template<typename _Func, typename _SfinaeType>
    using __has_is_transparent_t
      = typename __has_is_transparent<_Func, _SfinaeType>::type;


  template<typename _Func>
    concept __transparent_comparator
      = requires { typename _Func::is_transparent; };




}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/binders.h" 1 3
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/binders.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 107 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/binders.h" 3
  template<typename _Operation>
    class binder1st
    : public unary_function<typename _Operation::second_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::first_argument_type value;

    public:
      binder1st(const _Operation& __x,
  const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }



      typename _Operation::result_type
      operator()(typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }
    } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));


  template<typename _Operation, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
    inline binder1st<_Operation>
    bind1st(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
    }


  template<typename _Operation>
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::second_argument_type value;

    public:
      binder2nd(const _Operation& __x,
  const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }



      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }
    } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));


  template<typename _Operation, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    }



}

#pragma GCC diagnostic pop
# 1442 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_function.h" 2 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 3
  template<typename _Tp>
    struct __is_integer_nonstrict
    : public std::__is_integer<_Tp>
    {
      using std::__is_integer<_Tp>::__value;


      enum { __width = __value ? sizeof(_Tp) * 8 : 0 };
    };

  template<typename _Value>
    struct __numeric_traits_integer
    {

      static_assert(__is_integer_nonstrict<_Value>::__value,
      "invalid specialization");




      static const bool __is_signed = (_Value)(-1) < 0;
      static const int __digits
 = __is_integer_nonstrict<_Value>::__width - __is_signed;


      static const _Value __max = __is_signed
 ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1)
 : ~(_Value)0;
      static const _Value __min = __is_signed ? -__max - 1 : (_Value)0;
    };

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

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

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

  template<typename _Value>
    const int __numeric_traits_integer<_Value>::__digits;
# 132 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 3
  __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict<unsigned __int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; };






  template<typename _Tp>
    using __int_traits = __numeric_traits_integer<_Tp>;
# 159 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 3
  template<typename _Value>
    struct __numeric_traits_floating
    {

      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);


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

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

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

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

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






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

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

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

  template<>
    struct __numeric_traits<long double>
    : public __numeric_traits_floating<long double>
    { };
# 241 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/numeric_traits.h" 3
}
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 1 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp>
    struct tuple_size;





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

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

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

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


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



  template<size_t __i, typename _Tp>
    struct tuple_element;


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

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

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

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





  template<typename _Tp, typename... _Types>
    constexpr size_t
    __find_uniq_type_in_pack()
    {
      constexpr size_t __sz = sizeof...(_Types);
      constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... };
      size_t __n = __sz;
      for (size_t __i = 0; __i < __sz; ++__i)
 {
   if (__found[__i])
     {
       if (__n < __sz)
  return __sz;
       __n = __i;
     }
 }
      return __n;
    }
# 136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 3
  template<size_t __i, typename _Tp>
    using tuple_element_t = typename tuple_element<__i, _Tp>::type;




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


  template<size_t _Num>
    struct _Build_index_tuple
    {

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


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




    };




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

      static_assert(is_integral_v<_Tp>);

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


  template<typename _Tp, _Tp _Num>
    using make_integer_sequence

      = __make_integer_seq<integer_sequence, _Tp, _Num>;





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


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


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




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

  inline constexpr in_place_t in_place{};

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

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

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

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

  template<typename>
    inline constexpr bool __is_in_place_type_v = false;

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

  template<typename>
    inline constexpr bool __is_in_place_index_v = false;

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




  template<size_t _Np, typename... _Types>
    struct _Nth_type
    { using type = __type_pack_element<_Np, _Types...>; };
# 275 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 3
  namespace ranges::__detail
  {
    template<typename _Range>
      inline constexpr bool __is_subrange = false;
  }




  struct _Swallow_assign
  {
    template<class _Tp>
      constexpr const _Swallow_assign&
      operator=(const _Tp&) const noexcept
      { return *this; }
  };
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 3
  inline constexpr _Swallow_assign ignore{};
# 320 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/utility.h" 3
}
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };


  inline constexpr piecewise_construct_t piecewise_construct =
    piecewise_construct_t();




  template<typename _T1, typename _T2>
    struct pair;

  template<typename...>
    class tuple;





  template<typename _Tp, size_t _Nm>
    struct array;

  template<size_t...>
    struct _Index_tuple;

  template<typename _Tp>
    class complex;

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

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

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

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

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

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

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

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

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

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

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

  template<size_t _Int, typename _Tp, size_t _Nm>
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&&) noexcept;
# 278 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  template<typename _U1, typename _U2> class __pair_base
  {







  };
# 301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    struct pair
    : public __pair_base<_T1, _T2>
    {
      typedef _T1 first_type;
      typedef _T2 second_type;

      _T1 first;
      _T2 second;


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

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


      constexpr void
      swap(pair& __p)
      noexcept(__and_<__is_nothrow_swappable<_T1>,
        __is_nothrow_swappable<_T2>>::value)
      {
 using std::swap;
 swap(first, __p.first);
 swap(second, __p.second);
      }
# 349 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
    private:
      template<typename... _Args1, size_t... _Indexes1,
        typename... _Args2, size_t... _Indexes2>
 constexpr
 pair(tuple<_Args1...>&, tuple<_Args2...>&,
      _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
    public:





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

    private:


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

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

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


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

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



 }
# 444 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
    public:


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





      template<typename _U1, typename _U2>

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




      template<typename _U1, typename _U2>

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


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

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


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

      template<typename _U1, typename _U2>
 requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<_U1, _U2>())
 pair(pair<_U1, _U2>&&) = delete;
# 557 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  private:

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

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

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_nothrow_assignable()
 {
   if constexpr (is_nothrow_assignable_v<_T1&, _U1>)
     return is_nothrow_assignable_v<_T2&, _U2>;
   return false;
 }
# 605 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  public:

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


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


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


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


      template<typename _U1, typename _U2>
 constexpr pair&
 operator=(pair<_U1, _U2>&& __p)
 noexcept(_S_nothrow_assignable<_U1, _U2>())
 requires (_S_assignable<_U1, _U2>())
 {
   first = std::forward<_U1>(__p.first);
   second = std::forward<_U2>(__p.second);
   return *this;
 }
# 1015 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
    };




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







  template<typename _T1, typename _T2, typename _U1, typename _U2>
    [[nodiscard]]
    constexpr bool
    operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
    requires requires {
      { __x.first == __y.first } -> __detail::__boolean_testable;
      { __x.second == __y.second } -> __detail::__boolean_testable;
    }
    { return __x.first == __y.first && __x.second == __y.second; }
# 1045 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  template<typename _T1, typename _T2, typename _U1, typename _U2>
    [[nodiscard]]
    constexpr common_comparison_category_t<__detail::__synth3way_t<_T1, _U1>,
        __detail::__synth3way_t<_T2, _U2>>
    operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
    {
      if (auto __c = __detail::__synth3way(__x.first, __y.first); __c != 0)
 return __c;
      return __detail::__synth3way(__x.second, __y.second);
    }
# 1112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    constexpr inline


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



    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }
# 1135 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  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;
# 1161 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
    }
# 1184 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
    { };



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


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


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


  template<typename _Tp1, typename _Tp2>
    inline constexpr size_t tuple_size_v<pair<_Tp1, _Tp2>> = 2;

  template<typename _Tp1, typename _Tp2>
    inline constexpr size_t tuple_size_v<const pair<_Tp1, _Tp2>> = 2;



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++14-extensions"
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Tp>
    inline constexpr bool __is_pair = false;

  template<typename _Tp, typename _Up>
    inline constexpr bool __is_pair<pair<_Tp, _Up>> = true;
#pragma GCC diagnostic pop



  template<size_t _Int>
    struct __pair_get;

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

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

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

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp1&&
 __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<const _Tp1>(__pair.first); }
    };

  template<>
    struct __pair_get<1>
    {
      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp2&
 __get(pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp2&&
 __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<_Tp2>(__pair.second); }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp2&
 __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp2&&
 __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<const _Tp2>(__pair.second); }
    };






  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__get(__in); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__move_get(std::move(__in)); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(const pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__const_get(__in); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(const pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }



  template <typename _Tp, typename _Up>
    constexpr _Tp&
    get(pair<_Tp, _Up>& __p) noexcept
    { return __p.first; }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&
    get(const pair<_Tp, _Up>& __p) noexcept
    { return __p.first; }

  template <typename _Tp, typename _Up>
    constexpr _Tp&&
    get(pair<_Tp, _Up>&& __p) noexcept
    { return std::move(__p.first); }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&&
    get(const pair<_Tp, _Up>&& __p) noexcept
    { return std::move(__p.first); }

  template <typename _Tp, typename _Up>
    constexpr _Tp&
    get(pair<_Up, _Tp>& __p) noexcept
    { return __p.second; }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&
    get(const pair<_Up, _Tp>& __p) noexcept
    { return __p.second; }

  template <typename _Tp, typename _Up>
    constexpr _Tp&&
    get(pair<_Up, _Tp>&& __p) noexcept
    { return std::move(__p.second); }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&&
    get(const pair<_Up, _Tp>&& __p) noexcept
    { return std::move(__p.second); }
# 1366 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_pair.h" 3
}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/debug/debug.h" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/predefined_ops.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/predefined_ops.h" 3
namespace __gnu_cxx
{
namespace __ops
{
  struct _Iter_less_iter
  {
    template<typename _Iterator1, typename _Iterator2>
      constexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 < *__it2; }
  };

  constexpr
  inline _Iter_less_iter
  __iter_less_iter()
  { return _Iter_less_iter(); }

  struct _Iter_less_val
  {

    constexpr _Iter_less_val() = default;




    constexpr
    explicit
    _Iter_less_val(_Iter_less_iter) { }

    template<typename _Iterator, typename _Value>
      constexpr
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it < __val; }
  };

  constexpr
  inline _Iter_less_val
  __iter_less_val()
  { return _Iter_less_val(); }

  constexpr
  inline _Iter_less_val
  __iter_comp_val(_Iter_less_iter)
  { return _Iter_less_val(); }

  struct _Val_less_iter
  {

    constexpr _Val_less_iter() = default;




    constexpr
    explicit
    _Val_less_iter(_Iter_less_iter) { }

    template<typename _Value, typename _Iterator>
      constexpr
      bool
      operator()(_Value& __val, _Iterator __it) const
      { return __val < *__it; }
  };

  constexpr
  inline _Val_less_iter
  __val_less_iter()
  { return _Val_less_iter(); }

  constexpr
  inline _Val_less_iter
  __val_comp_iter(_Iter_less_iter)
  { return _Val_less_iter(); }

  struct _Iter_equal_to_iter
  {
    template<typename _Iterator1, typename _Iterator2>
      constexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 == *__it2; }
  };

  constexpr
  inline _Iter_equal_to_iter
  __iter_equal_to_iter()
  { return _Iter_equal_to_iter(); }

  struct _Iter_equal_to_val
  {
    template<typename _Iterator, typename _Value>
      constexpr
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it == __val; }
  };

  constexpr
  inline _Iter_equal_to_val
  __iter_equal_to_val()
  { return _Iter_equal_to_val(); }

  constexpr
  inline _Iter_equal_to_val
  __iter_comp_val(_Iter_equal_to_iter)
  { return _Iter_equal_to_val(); }

  template<typename _Compare>
    struct _Iter_comp_iter
    {
      _Compare _M_comp;

      explicit constexpr
      _Iter_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      template<typename _Iterator1, typename _Iterator2>
        constexpr
        bool
        operator()(_Iterator1 __it1, _Iterator2 __it2)
        { return bool(_M_comp(*__it1, *__it2)); }
    };

  template<typename _Compare>
    constexpr
    inline _Iter_comp_iter<_Compare>
    __iter_comp_iter(_Compare __comp)
    { return _Iter_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Iter_comp_val
    {
      _Compare _M_comp;

      constexpr
      explicit
      _Iter_comp_val(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      constexpr
      explicit
      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


      constexpr
      explicit
      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Iterator, typename _Value>
 constexpr
 bool
 operator()(_Iterator __it, _Value& __val)
 { return bool(_M_comp(*__it, __val)); }
    };

  template<typename _Compare>
    constexpr
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Compare __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    constexpr
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Val_comp_iter
    {
      _Compare _M_comp;

      constexpr
      explicit
      _Val_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      constexpr
      explicit
      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


      constexpr
      explicit
      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Value, typename _Iterator>
 constexpr
 bool
 operator()(_Value& __val, _Iterator __it)
 { return bool(_M_comp(__val, *__it)); }
    };

  template<typename _Compare>
    constexpr
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Compare __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    constexpr
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Value>
    struct _Iter_equals_val
    {
      _Value& _M_value;

      constexpr
      explicit
      _Iter_equals_val(_Value& __value)
 : _M_value(__value)
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return *__it == _M_value; }
    };

  template<typename _Value>
    constexpr
    inline _Iter_equals_val<_Value>
    __iter_equals_val(_Value& __val)
    { return _Iter_equals_val<_Value>(__val); }

  template<typename _Iterator1>
    struct _Iter_equals_iter
    {
      _Iterator1 _M_it1;

      constexpr
      explicit
      _Iter_equals_iter(_Iterator1 __it1)
 : _M_it1(__it1)
      { }

      template<typename _Iterator2>
 constexpr
 bool
 operator()(_Iterator2 __it2)
 { return *__it2 == *_M_it1; }
    };

  template<typename _Iterator>
    constexpr
    inline _Iter_equals_iter<_Iterator>
    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
    { return _Iter_equals_iter<_Iterator>(__it); }

  template<typename _Predicate>
    struct _Iter_pred
    {
      _Predicate _M_pred;

      constexpr
      explicit
      _Iter_pred(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
    constexpr
    inline _Iter_pred<_Predicate>
    __pred_iter(_Predicate __pred)
    { return _Iter_pred<_Predicate>(std::move(__pred)); }

  template<typename _Compare, typename _Value>
    struct _Iter_comp_to_val
    {
      _Compare _M_comp;
      _Value& _M_value;

      constexpr
      _Iter_comp_to_val(_Compare __comp, _Value& __value)
 : _M_comp(std::move(__comp)), _M_value(__value)
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return bool(_M_comp(*__it, _M_value)); }
    };

  template<typename _Compare, typename _Value>
    _Iter_comp_to_val<_Compare, _Value>
    constexpr
    __iter_comp_val(_Compare __comp, _Value &__val)
    {
      return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
    }

  template<typename _Compare, typename _Iterator1>
    struct _Iter_comp_to_iter
    {
      _Compare _M_comp;
      _Iterator1 _M_it1;

      constexpr
      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
 : _M_comp(std::move(__comp)), _M_it1(__it1)
      { }

      template<typename _Iterator2>
 constexpr
 bool
 operator()(_Iterator2 __it2)
 { return bool(_M_comp(*__it2, *_M_it1)); }
    };

  template<typename _Compare, typename _Iterator>
    constexpr
    inline _Iter_comp_to_iter<_Compare, _Iterator>
    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
    {
      return _Iter_comp_to_iter<_Compare, _Iterator>(
   std::move(__comp._M_comp), __it);
    }

  template<typename _Predicate>
    struct _Iter_negate
    {
      _Predicate _M_pred;

      constexpr
      explicit
      _Iter_negate(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return !bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
    constexpr
    inline _Iter_negate<_Predicate>
    __negate(_Iter_pred<_Predicate> __pred)
    { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }

}
}
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 87 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
  template<typename _To, typename _From>
    [[nodiscard]]
    constexpr _To
    bit_cast(const _From& __from) noexcept

    requires (sizeof(_To) == sizeof(_From))
      && is_trivially_copyable_v<_To> && is_trivially_copyable_v<_From>

    {
      return __builtin_bit_cast(_To, __from);
    }
# 157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
  template<typename _Tp>
    constexpr _Tp
    __rotl(_Tp __x, int __s) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if constexpr ((_Nd & (_Nd - 1)) == 0)
 {


   constexpr unsigned __uNd = _Nd;
   const unsigned __r = __s;
   return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd));
 }
      const int __r = __s % _Nd;
      if (__r == 0)
 return __x;
      else if (__r > 0)
 return (__x << __r) | (__x >> ((_Nd - __r) % _Nd));
      else
 return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd));
    }

  template<typename _Tp>
    constexpr _Tp
    __rotr(_Tp __x, int __s) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if constexpr ((_Nd & (_Nd - 1)) == 0)
 {


   constexpr unsigned __uNd = _Nd;
   const unsigned __r = __s;
   return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd));
 }
      const int __r = __s % _Nd;
      if (__r == 0)
 return __x;
      else if (__r > 0)
 return (__x >> __r) | (__x << ((_Nd - __r) % _Nd));
      else
 return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd));
    }

  template<typename _Tp>
    constexpr int
    __countl_zero(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;


      return __builtin_clzg(__x, _Nd);
# 249 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
    }

  template<typename _Tp>
    constexpr int
    __countl_one(_Tp __x) noexcept
    {
      return std::__countl_zero<_Tp>((_Tp)~__x);
    }

  template<typename _Tp>
    constexpr int
    __countr_zero(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;


      return __builtin_ctzg(__x, _Nd);
# 294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
    }

  template<typename _Tp>
    constexpr int
    __countr_one(_Tp __x) noexcept
    {
      return std::__countr_zero((_Tp)~__x);
    }

  template<typename _Tp>
    constexpr int
    __popcount(_Tp __x) noexcept
    {

      return __builtin_popcountg(__x);
# 334 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
    }

  template<typename _Tp>
    constexpr bool
    __has_single_bit(_Tp __x) noexcept
    { return std::__popcount(__x) == 1; }

  template<typename _Tp>
    constexpr _Tp
    __bit_ceil(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;
      if (__x == 0 || __x == 1)
        return 1;
      auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u));




      if (!std::__is_constant_evaluated())
 {
   do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) std::__glibcxx_assert_fail(); } while (false);
 }

      using __promoted_type = decltype(__x << 1);
      if constexpr (!is_same<__promoted_type, _Tp>::value)
 {





   const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2;
   __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp;
 }
      return (_Tp)1u << __shift_exponent;
    }

  template<typename _Tp>
    constexpr _Tp
    __bit_floor(_Tp __x) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if (__x == 0)
        return 0;
      return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1)));
    }

  template<typename _Tp>
    constexpr int
    __bit_width(_Tp __x) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      return _Nd - std::__countl_zero(__x);
    }






  template<typename _Tp>
    concept __unsigned_integer = __is_unsigned_integer<_Tp>::value;





  template<__unsigned_integer _Tp>
    [[nodiscard]] constexpr _Tp
    rotl(_Tp __x, int __s) noexcept
    { return std::__rotl(__x, __s); }


  template<__unsigned_integer _Tp>
    [[nodiscard]] constexpr _Tp
    rotr(_Tp __x, int __s) noexcept
    { return std::__rotr(__x, __s); }




  template<__unsigned_integer _Tp>
    constexpr int
    countl_zero(_Tp __x) noexcept
    { return std::__countl_zero(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countl_one(_Tp __x) noexcept
    { return std::__countl_one(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countr_zero(_Tp __x) noexcept
    { return std::__countr_zero(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countr_one(_Tp __x) noexcept
    { return std::__countr_one(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    popcount(_Tp __x) noexcept
    { return std::__popcount(__x); }






  template<__unsigned_integer _Tp>
    constexpr bool
    has_single_bit(_Tp __x) noexcept
    { return std::__has_single_bit(__x); }


  template<__unsigned_integer _Tp>
    constexpr _Tp
    bit_ceil(_Tp __x) noexcept
    { return std::__bit_ceil(__x); }


  template<__unsigned_integer _Tp>
    constexpr _Tp
    bit_floor(_Tp __x) noexcept
    { return std::__bit_floor(__x); }




  template<__unsigned_integer _Tp>
    constexpr int
    bit_width(_Tp __x) noexcept
    { return std::__bit_width(__x); }
# 486 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bit" 3
  enum class endian
  {
    little = 1234,
    big = 4321,
    native = 1234
  };





}
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{






  template<typename _Tp, typename _Up>
    constexpr
    inline int
    __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num)
    {

      static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp");


      if (std::is_constant_evaluated())
 {
   for(; __num > 0; ++__first1, ++__first2, --__num)
     if (*__first1 != *__first2)
       return *__first1 < *__first2 ? -1 : 1;
   return 0;
 }
      else

 return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num);
    }
# 153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
# 186 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
      swap(*__a, *__b);

    }
# 202 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {





                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 231 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {



      if (__b < __a)
 return __b;
      return __a;
    }
# 255 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {



      if (__a < __b)
 return __b;
      return __a;
    }
# 279 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }



  template<typename _Tp, typename _Ref, typename _Ptr>
    struct _Deque_iterator;

  struct _Bit_iterator;






  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_move_a2(
 istreambuf_iterator<_CharT, char_traits<_CharT> >,
 istreambuf_iterator<_CharT, char_traits<_CharT> >,
 std::_Deque_iterator<_CharT, _CharT&, _CharT*>);



  template<typename _OutIter, typename _InIter, typename _Sent = _InIter>
    concept __memcpyable_iterators
      = contiguous_iterator<_OutIter> && contiguous_iterator<_InIter>
   && sized_sentinel_for<_Sent, _InIter>
   && requires (_OutIter __o, _InIter __i) {
     requires !!__memcpyable<decltype(std::to_address(__o)),
        decltype(std::to_address(__i))>::__value;
   };
# 395 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<bool _IsMove, typename _OutIter, typename _InIter>
    __attribute__((__always_inline__)) constexpr
    inline void
    __assign_one(_OutIter& __out, _InIter& __in)
    {

      if constexpr (_IsMove)
 *__out = std::move(*__in);
      else

 *__out = *__in;
    }

  template<bool _IsMove, typename _InIter, typename _Sent, typename _OutIter>
    constexpr
    inline _OutIter
    __copy_move_a2(_InIter __first, _Sent __last, _OutIter __result)
    {
      typedef __decltype(*__first) _InRef;
      typedef __decltype(*__result) _OutRef;
      if constexpr (!__is_trivially_assignable(_OutRef, _InRef))
 { }
      else if (std::__is_constant_evaluated())
 { }
      else if constexpr (__memcpyable<_OutIter, _InIter>::__value)
 {
   ptrdiff_t __n = std::distance(__first, __last);
   if (__builtin_expect(__n > 1, true))
     {
       __builtin_memmove(__result,
    __first,
    __n * sizeof(*__first));
       __result += __n;
     }
   else if (__n == 1)
     {
       std::__assign_one<_IsMove>(__result, __first);
       ++__result;
     }
   return __result;
 }

      else if constexpr (__memcpyable_iterators<_OutIter, _InIter, _Sent>)
 {
   if (auto __n = __last - __first; __n > 1) [[likely]]
     {
       void* __dest = std::to_address(__result);
       const void* __src = std::to_address(__first);
       size_t __nbytes = __n * sizeof(iter_value_t<_InIter>);


       (void) std::to_address(__result += __n);
       (void) std::to_address(__first += __n);
       __builtin_memmove(__dest, __src, __nbytes);
     }
   else if (__n == 1)
     {
       std::__assign_one<_IsMove>(__result, __first);
       ++__result;
     }
   return __result;
 }


      for (; __first != __last; ++__result, (void)++__first)
 std::__assign_one<_IsMove>(__result, __first);
      return __result;
    }
#pragma GCC diagnostic pop

  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>
    __attribute__((__always_inline__))
    constexpr
    inline _OI
    __copy_move_a1(_II __first, _II __last, _OI __result)
    { return std::__copy_move_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _OI>
    __attribute__((__always_inline__))
    constexpr
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
          std::__niter_base(__last),
          std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    constexpr
    _OI
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    constexpr
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_a(_II, _II,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    constexpr
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _InputIterator, typename _Size, typename _OutputIterator>
    constexpr
    _OutputIterator
    __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result,
        bool)
    {
      typedef __decltype(*__first) _InRef;
      typedef __decltype(*__result) _OutRef;
      if constexpr (!__is_trivially_assignable(_OutRef, _InRef))
 { }

      else if (std::is_constant_evaluated())
 { }

      else if constexpr (__memcpyable<_OutputIterator,
            _InputIterator>::__value)
 {
   if (__builtin_expect(__n > 1, true))
     {
       __builtin_memmove(__result,
    __first,
    __n * sizeof(*__first));
       __result += __n;
     }
   else if (__n == 1)
     *__result++ = *__first;
   return __result;
 }

      else if constexpr (__memcpyable_iterators<_OutputIterator,
      _InputIterator>)
 {
   if (__n > 1) [[likely]]
     {
       void* __dest = std::to_address(__result);
       const void* __src = std::to_address(__first);
       size_t __nbytes = __n * sizeof(iter_value_t<_InputIterator>);


       (void) std::to_address(__result += __n);
       (void) std::to_address(__first += __n);
       __builtin_memmove(__dest, __src, __nbytes);
     }
   else if (__n == 1)
     *__result++ = *__first;
   return __result;
 }


      if (__n > 0)
 {
   while (true)
     {
       *__result = *__first;
       ++__result;
       if (--__n > 0)
  ++__first;
       else
  break;
     }
 }
      return __result;
    }
#pragma GCC diagnostic pop


  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value, _CharT*>::__type
    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >,
        _Size, _CharT*, bool);

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size,
        std::_Deque_iterator<_CharT, _CharT&, _CharT*>,
        bool);
# 630 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    constexpr
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {




                                                                       ;

      return std::__copy_move_a<__is_move_iterator<_II>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 663 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    constexpr
    inline _OI
    move(_II __first, _II __last, _OI __result)
    {




                                                                       ;

      return std::__copy_move_a<true>(std::__miter_base(__first),
          std::__miter_base(__last), __result);
    }






#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<bool _IsMove, typename _BI1, typename _BI2>
    constexpr
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef __decltype(*__first) _InRef;
      typedef __decltype(*__result) _OutRef;
      if constexpr (!__is_trivially_assignable(_OutRef, _InRef))
       { }

      else if (std::is_constant_evaluated())
       { }

      else if constexpr (__memcpyable<_BI2, _BI1>::__value)
 {
   ptrdiff_t __n = std::distance(__first, __last);
   std::advance(__result, -__n);
   if (__builtin_expect(__n > 1, true))
     {
       __builtin_memmove(__result,
    __first,
    __n * sizeof(*__first));
     }
   else if (__n == 1)
     std::__assign_one<_IsMove>(__result, __first);
   return __result;
 }

      else if constexpr (__memcpyable_iterators<_BI2, _BI1>)
 {
   if (auto __n = __last - __first; __n > 1) [[likely]]
     {
       const void* __src = std::to_address(__first);


       (void) std::to_address(__result -= __n);
       (void) std::to_address(__first += __n);
       void* __dest = std::to_address(__result);
       size_t __nbytes = __n * sizeof(iter_value_t<_BI1>);
       __builtin_memmove(__dest, __src, __nbytes);
     }
   else if (__n == 1)
     {
       --__result;
       std::__assign_one<_IsMove>(__result, __first);
     }
   return __result;
 }


      while (__first != __last)
 {
   --__last;
   --__result;
   std::__assign_one<_IsMove>(__result, __last);
 }
      return __result;
    }
#pragma GCC diagnostic pop




  template<bool _IsMove, typename _BI1, typename _BI2>
    __attribute__((__always_inline__))
    constexpr
    inline _BI2
    __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
    { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       _OI);

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_backward_a1(
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_backward_a1(_II, _II,
       std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

  template<bool _IsMove, typename _II, typename _OI>
    __attribute__((__always_inline__))
    constexpr
    inline _OI
    __copy_move_backward_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_backward_a1<_IsMove>
    (std::__niter_base(__first), std::__niter_base(__last),
     std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    constexpr
    _OI
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    constexpr
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_backward_a(_II, _II,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    constexpr
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
# 833 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    __attribute__((__always_inline__))
    constexpr
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {





                                                                       ;

      return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 869 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    __attribute__((__always_inline__))
    constexpr
    inline _BI2
    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {





                                                                       ;

      return std::__copy_move_backward_a<true>(std::__miter_base(__first),
            std::__miter_base(__last),
            __result);
    }






#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _ForwardIterator, typename _Tp>
    constexpr
    inline void
    __fill_a1(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"




      const bool __load_outside_loop =


     __is_trivially_constructible(_Tp, const _Tp&)
     && __is_trivially_assignable(__decltype(*__first), const _Tp&)




     && sizeof(_Tp) <= sizeof(long long);
#pragma GCC diagnostic pop



      typedef typename __gnu_cxx::__conditional_type<__load_outside_loop,
           const _Tp,
           const _Tp&>::__type _Up;
      _Up __val(__value);
      for (; __first != __last; ++__first)
 *__first = __val;
    }
#pragma GCC diagnostic pop


  template<typename _Up, typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Up>::__value
        && (__are_same<_Up, _Tp>::__value
       || __memcpyable_integer<_Tp>::__width),
      void>::__type
    __fill_a1(_Up* __first, _Up* __last, const _Tp& __x)
    {


      const _Up __val = __x;

      if (std::is_constant_evaluated())
 {
   for (; __first != __last; ++__first)
     *__first = __val;
   return;
 }

      if (const size_t __len = __last - __first)
 __builtin_memset(__first, static_cast<unsigned char>(__val), __len);
    }

  template<typename _Ite, typename _Cont, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline void
    __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
       ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
       const _Tp& __value)
    { std::__fill_a1(__first.base(), __last.base(), __value); }

  template<typename _Tp, typename _VTp>
    void
    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const _VTp&);

  constexpr
  void
  __fill_a1(std::_Bit_iterator, std::_Bit_iterator,
     const bool&);

  template<typename _FIte, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline void
    __fill_a(_FIte __first, _FIte __last, const _Tp& __value)
    { std::__fill_a1(__first, __last, __value); }

  template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>
    constexpr
    void
    __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const _Tp&);
# 1000 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {



                                                     ;

      std::__fill_a(__first, __last, __value);
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"

  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; }
# 1055 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  inline constexpr long long
  __size_to_integer(float __n) { return (long long)__n; }
  inline constexpr long long
  __size_to_integer(double __n) { return (long long)__n; }
  inline constexpr long long
  __size_to_integer(long double __n) { return (long long)__n; }




#pragma GCC diagnostic pop

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
#pragma GCC diagnostic ignored "-Wlong-long"
  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline _OutputIterator
    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
    {

      const bool __load_outside_loop =


     __is_trivially_constructible(_Tp, const _Tp&)
     && __is_trivially_assignable(__decltype(*__first), const _Tp&)




     && sizeof(_Tp) <= sizeof(long long);



      typedef typename __gnu_cxx::__conditional_type<__load_outside_loop,
           const _Tp,
           const _Tp&>::__type _Up;
      _Up __val(__value);
      for (; __n > 0; --__n, (void) ++__first)
 *__first = __val;
      return __first;
    }
#pragma GCC diagnostic pop

  template<typename _Ite, typename _Seq, typename _Cat, typename _Size,
    typename _Tp>
    constexpr
    ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
        _Size __n, const _Tp& __value,
        std::input_iterator_tag);

  template<typename _OutputIterator, typename _Size, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::output_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::input_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::random_access_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      if (__n <= 0)
 return __first;

                                                    ;

      std::__fill_a(__first, __first + __n, __value);
      return __first + __n;
    }
# 1169 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _OI, typename _Size, typename _Tp>
    __attribute__((__always_inline__))
    constexpr
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {



      return std::__fill_n_a(__first, std::__size_to_integer(__n), __value,
          std::__iterator_category(__first));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
 constexpr
 static bool
 equal(_II1 __first1, _II1 __last1, _II2 __first2)
 {
   for (; __first1 != __last1; ++__first1, (void) ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
 constexpr
 static bool
 equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
 {
   if (const size_t __len = (__last1 - __first1))
     return !std::__memcmp(__first1, __first2, __len);
   return true;
 }
    };

  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   _II);

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(_II, _II,
  std::_Deque_iterator<_Tp, _Ref, _Ptr>);

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      const bool __simple = ((__is_integer<_ValueType1>::__value

    || __is_pointer(_ValueType1)



    || is_same_v<_ValueType1, byte>

        ) && __memcmpable<_II1, _II2>::__value);
      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }

  template<typename _II1, typename _II2>
    __attribute__((__always_inline__))
    constexpr
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      return std::__equal_aux1(std::__niter_base(__first1),
          std::__niter_base(__last1),
          std::__niter_base(__first2));
    }

  template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>
    constexpr
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  _II2);

  template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __equal_aux(_II1, _II1,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename _II1, typename _Seq1, typename _Cat1,
    typename _II2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
 constexpr
 static _II1
 __newlast1(_II1, _II1 __last1, _II2, _II2)
 { return __last1; }

      template<typename _II>
 constexpr
 static bool
 __cnd2(_II __first, _II __last)
 { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
 constexpr
 static _RAI1
 __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
 {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
 static constexpr bool
 __cnd2(_RAI, _RAI)
 { return true; }
    };

  template<typename _II1, typename _II2, typename _Compare>
    constexpr
    bool
    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2,
       _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
    ++__first1, (void)++__first2)
 {
   if (__comp(__first1, __first2))
     return true;
   if (__comp(__first2, __first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
 constexpr
 static bool
 __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
 {
   using __gnu_cxx::__ops::__iter_less_iter;
   return std::__lexicographical_compare_impl(__first1, __last1,
           __first2, __last2,
           __iter_less_iter());
 }

      template<typename _II1, typename _II2>
 constexpr
 static int
 __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
 {
   while (__first1 != __last1)
     {
       if (__first2 == __last2)
  return +1;
       if (*__first1 < *__first2)
  return -1;
       if (*__first2 < *__first1)
  return +1;
       ++__first1;
       ++__first2;
     }
   return int(__first2 == __last2) - 1;
 }
    };

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
 constexpr
 static bool
 __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 { return __3way(__first1, __last1, __first2, __last2) < 0; }

      template<typename _Tp, typename _Up>
 constexpr
 static ptrdiff_t
 __3way(const _Tp* __first1, const _Tp* __last1,
        const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   if (const size_t __len = std::min(__len1, __len2))
     if (int __result = std::__memcmp(__first1, __first2, __len))
       return __result;
   return ptrdiff_t(__len1 - __len2);
 }
    };

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __lexicographical_compare_aux1(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;

      const bool __simple =
 (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value
  && __is_pointer(_II1) && __is_pointer(_II2)




  && !is_volatile_v<remove_reference_t<iter_reference_t<_II1>>>
  && !is_volatile_v<remove_reference_t<iter_reference_t<_II2>>>

  );




      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2>
    bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 _Tp2*, _Tp2*);

  template<typename _Tp1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __lexicographical_compare_aux1(_Tp1*, _Tp1*,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      return std::__lexicographical_compare_aux1(std::__niter_base(__first1),
       std::__niter_base(__last1),
       std::__niter_base(__first2),
       std::__niter_base(__last2));
    }

  template<typename _Iter1, typename _Seq1, typename _Cat1,
    typename _II2>
    constexpr
    bool
    __lexicographical_compare_aux(
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  _II2, _II2);

  template<typename _II1,
    typename _Iter2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __lexicographical_compare_aux(
  _II1, _II1,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&);

  template<typename _Iter1, typename _Seq1, typename _Cat1,
    typename _Iter2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __lexicographical_compare_aux(
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&);

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    constexpr
    _ForwardIterator
    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 1532 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




                                                                  ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val());
    }



  template<typename _Tp>
    inline constexpr _Tp
    __lg(_Tp __n)
    {

      return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1;
# 1568 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
    }
# 1584 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {






                                                                         ;

      return std::__equal_aux(__first1, __last1, __first2);
    }
# 1615 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _BinaryPredicate __binary_pred)
    {



                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return true;
    }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"


  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if constexpr (_RAIters::value)
 {
   if ((__last1 - __first1) != (__last2 - __first2))
     return false;
   return std::equal(__first1, __last1, __first2);
 }
      else
 {
   for (; __first1 != __last1 && __first2 != __last2;
        ++__first1, (void)++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return __first1 == __last1 && __first2 == __last2;
 }
    }


  template<typename _II1, typename _II2, typename _BinaryPredicate>
    constexpr
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
      _BinaryPredicate __binary_pred)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if constexpr (_RAIters::value)
 {
   if ((__last1 - __first1) != (__last2 - __first2))
     return false;
   return std::equal(__first1, __last1, __first2,
           __binary_pred);
 }
      else
 {
   for (; __first1 != __last1 && __first2 != __last2;
        ++__first1, (void)++__first2)
     if (!bool(__binary_pred(*__first1, *__first2)))
       return false;
   return __first1 == __last1 && __first2 == __last2;
 }
    }
#pragma GCC diagnostic pop
# 1706 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {






                                                       ;
                                                       ;

      return std::__equal4(__first1, __last1, __first2, __last2);
    }
# 1739 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
    {



                                                       ;
                                                       ;

      return std::__equal4(__first1, __last1, __first2, __last2,
          __binary_pred);
    }
# 1771 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {
# 1786 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
                                                       ;
                                                       ;

      return std::__lexicographical_compare_aux(__first1, __last1,
      __first2, __last2);
    }
# 1806 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2, typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2, _Compare __comp)
    {



                                                       ;
                                                       ;

      return std::__lexicographical_compare_impl
 (__first1, __last1, __first2, __last2,
  __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }





  template<typename _Iter1, typename _Iter2>
    concept __memcmp_ordered_with
      = (__is_memcmp_ordered_with<iter_value_t<_Iter1>,
      iter_value_t<_Iter2>>::__value)
   && contiguous_iterator<_Iter1> && contiguous_iterator<_Iter2>;



  template<typename _Tp>
    constexpr auto
    __min_cmp(_Tp __x, _Tp __y)
    {
      struct _Res {
 _Tp _M_min;
 decltype(__x <=> __y) _M_cmp;
      };
      auto __c = __x <=> __y;
      if (__c > 0)
 return _Res{__y, __c};
      return _Res{__x, __c};
    }
# 1860 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _Comp>
    [[nodiscard]] constexpr auto
    lexicographical_compare_three_way(_InputIter1 __first1,
          _InputIter1 __last1,
          _InputIter2 __first2,
          _InputIter2 __last2,
          _Comp __comp)
    -> decltype(__comp(*__first1, *__first2))
    {



                                                       ;
                                                       ;

      using _Cat = decltype(__comp(*__first1, *__first2));
      static_assert(same_as<common_comparison_category_t<_Cat>, _Cat>);

      if (!std::__is_constant_evaluated())
 if constexpr (same_as<_Comp, __detail::_Synth3way>
        || same_as<_Comp, compare_three_way>)
   if constexpr (__memcmp_ordered_with<_InputIter1, _InputIter2>)
     {
       const auto [__len, __lencmp] = std::
  __min_cmp(__last1 - __first1, __last2 - __first2);
       if (__len)
  {
    const auto __blen = __len * sizeof(*__first1);
    const auto __c
      = __builtin_memcmp(&*__first1, &*__first2, __blen) <=> 0;
    if (__c != 0)
      return __c;
  }
       return __lencmp;
     }

      while (__first1 != __last1)
 {
   if (__first2 == __last2)
     return strong_ordering::greater;
   if (auto __cmp = __comp(*__first1, *__first2); __cmp != 0)
     return __cmp;
   ++__first1;
   ++__first2;
 }
      return (__first2 == __last2) <=> true;
    }

  template<typename _InputIter1, typename _InputIter2>
    constexpr auto
    lexicographical_compare_three_way(_InputIter1 __first1,
          _InputIter1 __last1,
          _InputIter2 __first2,
          _InputIter2 __last2)
    {
      return std::
 lexicographical_compare_three_way(__first1, __last1, __first2, __last2,
       compare_three_way{});
    }


  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    constexpr
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 1949 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2)
    {






                                                       ;

      return std::__mismatch(__first1, __last1, __first2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 1983 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {



                                                       ;

      return std::__mismatch(__first1, __last1, __first2,
 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }


  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    constexpr
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __first2 != __last2
      && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 2031 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 2067 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _BinaryPredicate __binary_pred)
    {



                                                       ;
                                                       ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }





  template<typename _Iterator, typename _Predicate>
    constexpr
    inline _Iterator
    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
    {
#pragma GCC unroll 4
      while (__first != __last && !__pred(__first))
 ++__first;
      return __first;
    }

  template<typename _InputIterator, typename _Predicate>
    constexpr
    typename iterator_traits<_InputIterator>::difference_type
    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
 if (__pred(__first))
   ++__n;
      return __n;
    }

  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    _ForwardIterator
    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred)
    {
      __first = std::__find_if(__first, __last, __pred);
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = std::move(*__first);
     ++__result;
   }
      return __result;
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator1
    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __predicate)
    {

      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 return std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));


      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   __first1 =
     std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

   if (__first1 == __last1)
     return __last1;

   _ForwardIterator2 __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (__predicate(__current, __p))
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {


      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if (__first1 == __last1)
 return true;



      _ForwardIterator2 __last2 = __first2;
      std::advance(__last2, std::distance(__first1, __last1));
      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
 {
   if (__scan != std::__find_if(__first1, __scan,
     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
     continue;

   auto __matches
     = std::__count_if(__first2, __last2,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
   if (0 == __matches ||
       std::__count_if(__scan, __last1,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
       != __matches)
     return false;
 }
      return true;
    }
# 2230 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2)
    {






                                                       ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 2272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {






                                                       ;
                                                       ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
    }



}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/invoke.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/invoke.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/invoke.h" 3
}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 3
  template<typename _Res, typename... _ArgTypes>
    struct _Maybe_unary_or_binary_function { };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Res, typename _T1>
    struct _Maybe_unary_or_binary_function<_Res, _T1>
    : std::unary_function<_T1, _Res> { };


  template<typename _Res, typename _T1, typename _T2>
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
    : std::binary_function<_T1, _T2, _Res> { };

#pragma GCC diagnostic pop

  template<typename _Signature>
    struct _Mem_fn_traits;

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Mem_fn_traits_base
    {
      using __result_type = _Res;
      using __maybe_type
 = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
    };
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>
    { };
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 3
  template<typename _Tp>
    class reference_wrapper





    {
      _Tp* _M_data;

      constexpr
      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }

      static void _S_fun(_Tp&&) = delete;

      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
 using __not_same
   = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;

    public:
      typedef _Tp type;




      template<typename _Up, typename = __not_same<_Up>, typename
  = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
 constexpr
 reference_wrapper(_Up&& __uref)
 noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
 : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
 { }

      reference_wrapper(const reference_wrapper&) = default;

      reference_wrapper&
      operator=(const reference_wrapper&) = default;

      constexpr
      operator _Tp&() const noexcept
      { return this->get(); }

      constexpr
      _Tp&
      get() const noexcept
      { return *_M_data; }

      template<typename... _Args>
 constexpr
 typename __invoke_result<_Tp&, _Args...>::type
 operator()(_Args&&... __args) const
 noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value)
 {

   if constexpr (is_object_v<type>)
     static_assert(sizeof(type), "type must be complete");

   return std::__invoke(get(), std::forward<_Args>(__args)...);
 }
# 415 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/refwrap.h" 3
    };


  template<typename _Tp>
    reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;





  template<typename _Tp>
    constexpr
    inline reference_wrapper<_Tp>
    ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }


  template<typename _Tp>
    constexpr
    inline reference_wrapper<const _Tp>
    cref(const _Tp& __t) noexcept
    { return reference_wrapper<const _Tp>(__t); }

  template<typename _Tp>
    void ref(const _Tp&&) = delete;

  template<typename _Tp>
    void cref(const _Tp&&) = delete;


  template<typename _Tp>
    constexpr
    inline reference_wrapper<_Tp>
    ref(reference_wrapper<_Tp> __t) noexcept
    { return __t; }


  template<typename _Tp>
    constexpr
    inline reference_wrapper<const _Tp>
    cref(reference_wrapper<_Tp> __t) noexcept
    { return { __t.get() }; }




}
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/range_access.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/range_access.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/initializer_list" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/initializer_list" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  template<class _E>
    class initializer_list
    {
    public:
      typedef _E value_type;
      typedef const _E& reference;
      typedef const _E& const_reference;
      typedef size_t size_type;
      typedef const _E* iterator;
      typedef const _E* const_iterator;

    private:
      iterator _M_array;
      size_type _M_len;


      constexpr initializer_list(const_iterator __a, size_type __l)
      : _M_array(__a), _M_len(__l) { }

    public:
      constexpr initializer_list() noexcept
      : _M_array(0), _M_len(0) { }


      constexpr size_type
      size() const noexcept { return _M_len; }


      constexpr const_iterator
      begin() const noexcept { return _M_array; }


      constexpr const_iterator
      end() const noexcept { return begin() + size(); }
    };







  template<class _Tp>
    constexpr const _Tp*
    begin(initializer_list<_Tp> __ils) noexcept
    { return __ils.begin(); }







  template<class _Tp>
    constexpr const _Tp*
    end(initializer_list<_Tp> __ils) noexcept
    { return __ils.end(); }
}
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/range_access.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    begin(_Container& __cont) noexcept(noexcept(__cont.begin()))
    -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    begin(const _Container& __cont) noexcept(noexcept(__cont.begin()))
    -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    end(_Container& __cont) noexcept(noexcept(__cont.end()))
    -> decltype(__cont.end())
    { return __cont.end(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    end(const _Container& __cont) noexcept(noexcept(__cont.end()))
    -> decltype(__cont.end())
    { return __cont.end(); }





  template<typename _Tp, size_t _Nm>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr _Tp*
    begin(_Tp (&__arr)[_Nm]) noexcept
    { return __arr; }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr _Tp*
    end(_Tp (&__arr)[_Nm]) noexcept
    { return __arr + _Nm; }



  template<typename _Tp> class valarray;

  template<typename _Tp> _Tp* begin(valarray<_Tp>&) noexcept;
  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&) noexcept;
  template<typename _Tp> _Tp* end(valarray<_Tp>&) noexcept;
  template<typename _Tp> const _Tp* end(const valarray<_Tp>&) noexcept;






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    constexpr auto
    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
      -> decltype(std::begin(__cont))
    { return std::begin(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    constexpr auto
    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
      -> decltype(std::end(__cont))
    { return std::end(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rbegin(_Container& __cont) noexcept(noexcept(__cont.rbegin()))
      -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rbegin(const _Container& __cont) noexcept(noexcept(__cont.rbegin()))
      -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rend(_Container& __cont) noexcept(noexcept(__cont.rend()))
      -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rend(const _Container& __cont) noexcept(noexcept(__cont.rend()))
      -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Tp*>
    rbegin(_Tp (&__arr)[_Nm]) noexcept
    { return reverse_iterator<_Tp*>(__arr + _Nm); }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Tp*>
    rend(_Tp (&__arr)[_Nm]) noexcept
    { return reverse_iterator<_Tp*>(__arr); }






  template<typename _Tp>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<const _Tp*>
    rbegin(initializer_list<_Tp> __il) noexcept
    { return reverse_iterator<const _Tp*>(__il.end()); }






  template<typename _Tp>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<const _Tp*>
    rend(initializer_list<_Tp> __il) noexcept
    { return reverse_iterator<const _Tp*>(__il.begin()); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    crbegin(const _Container& __cont) noexcept(noexcept(std::rbegin(__cont)))
      -> decltype(std::rbegin(__cont))
    { return std::rbegin(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    crend(const _Container& __cont) noexcept(noexcept(std::rend(__cont)))
      -> decltype(std::rend(__cont))
    { return std::rend(__cont); }
# 271 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/range_access.h" 3
  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    size(const _Container& __cont) noexcept(noexcept(__cont.size()))
    -> decltype(__cont.size())
    { return __cont.size(); }




  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr size_t
    size(const _Tp (&)[_Nm]) noexcept
    { return _Nm; }





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
    -> decltype(__cont.empty())
    { return __cont.empty(); }




  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    empty(const _Tp (&)[_Nm]) noexcept
    { return false; }





  template <typename _Tp>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    empty(initializer_list<_Tp> __il) noexcept
    { return __il.size() == 0;}





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    data(_Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    data(const _Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr _Tp*
    data(_Tp (&__array)[_Nm]) noexcept
    { return __array; }





  template <typename _Tp>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr const _Tp*
    data(initializer_list<_Tp> __il) noexcept
    { return __il.begin(); }



  template<typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    ssize(const _Container& __cont) noexcept(noexcept(__cont.size()))
    -> common_type_t<ptrdiff_t, make_signed_t<decltype(__cont.size())>>
    {
      using type = make_signed_t<decltype(__cont.size())>;
      return static_cast<common_type_t<ptrdiff_t, type>>(__cont.size());
    }

  template<typename _Tp, ptrdiff_t _Num>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr ptrdiff_t
    ssize(const _Tp (&)[_Num]) noexcept
    { return _Num; }


}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/alloc_traits.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/alloc_traits.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++14-extensions"
#pragma GCC diagnostic ignored "-Wc++17-extensions"


  struct __allocator_traits_base
  {

    template<typename _Tp, typename _Up>



      struct __rebind : __replace_first_arg<_Tp, _Up>
      {
 static_assert(is_same<
   typename __replace_first_arg<_Tp, typename _Tp::value_type>::type,
   _Tp>::value,
   "allocator_traits<A>::rebind_alloc<A::value_type> must be A");
      };

    template<typename _Tp, typename _Up>

      requires requires { typename _Tp::template rebind<_Up>::other; }
      struct __rebind<_Tp, _Up>




      {
 using type = typename _Tp::template rebind<_Up>::other;

 static_assert(is_same<
   typename _Tp::template rebind<typename _Tp::value_type>::other,
   _Tp>::value,
   "allocator_traits<A>::rebind_alloc<A::value_type> must be A");
      };

  protected:
    template<typename _Tp>
      using __pointer = typename _Tp::pointer;
    template<typename _Tp>
      using __c_pointer = typename _Tp::const_pointer;
    template<typename _Tp>
      using __v_pointer = typename _Tp::void_pointer;
    template<typename _Tp>
      using __cv_pointer = typename _Tp::const_void_pointer;
    template<typename _Tp>
      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
    template<typename _Tp>
      using __pocma = typename _Tp::propagate_on_container_move_assignment;
    template<typename _Tp>
      using __pocs = typename _Tp::propagate_on_container_swap;
    template<typename _Tp>
      using __equal = __type_identity<typename _Tp::is_always_equal>;



    template<typename _Alloc, typename _Sz, typename _Vp>
      static constexpr bool __has_allocate_hint
 = requires (_Alloc& __a, _Sz __n, _Vp __hint) {
 __a.allocate(__n, __hint);
      };
# 133 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
    template<typename _Alloc, typename _Tp, typename... _Args>
      static constexpr bool __has_construct
 = requires (_Alloc& __a, _Tp* __p, _Args&&... __args) {
   __a.construct(__p, std::forward<_Args>(__args)...);
 };
    template<typename _Tp, typename... _Args>
      static constexpr bool __can_construct_at
 = requires (_Tp* __p, _Args&&... __args) {

   std::construct_at(__p, std::forward<_Args>(__args)...);



 };
    template<typename _Alloc, typename _Tp, typename... _Args>
      static constexpr bool __can_construct
 = __has_construct<_Alloc, _Tp, _Args...>
     || __can_construct_at<_Tp, _Args...>;
# 184 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
    template<typename _Alloc, typename _Tp>
      static constexpr bool __has_destroy = requires (_Alloc& __a, _Tp* __p) {
 __a.destroy(__p);
      };
# 202 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
    template<typename _Alloc>
      static constexpr bool __has_max_size = requires (const _Alloc& __a) {
 __a.max_size();
      };
# 220 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
    template<typename _Alloc>
      static constexpr bool __has_soccc = requires (const _Alloc& __a) {
 __a.select_on_container_copy_construction();
      };
# 235 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
  };

  template<typename _Alloc, typename _Up>
    using __alloc_rebind
      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
# 248 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
  template<typename _Alloc>
    struct allocator_traits : __allocator_traits_base
    {

      typedef _Alloc allocator_type;

      typedef typename _Alloc::value_type value_type;






      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

    private:

      template<template<typename> class _Func, typename _Tp, typename = void>
 struct _Ptr
 {
   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
 };

      template<template<typename> class _Func, typename _Tp>
 struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
 {
   using type = _Func<_Alloc>;
 };


      template<typename _A2, typename _PtrT, typename = void>
 struct _Diff
 { using type = typename pointer_traits<_PtrT>::difference_type; };

      template<typename _A2, typename _PtrT>
 struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
 { using type = typename _A2::difference_type; };


      template<typename _A2, typename _DiffT, typename = void>
 struct _Size : make_unsigned<_DiffT> { };

      template<typename _A2, typename _DiffT>
 struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
 { using type = typename _A2::size_type; };

    public:






      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;







      using void_pointer = typename _Ptr<__v_pointer, void>::type;







      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;







      using difference_type = typename _Diff<_Alloc, pointer>::type;







      using size_type = typename _Size<_Alloc, difference_type>::type;







      using propagate_on_container_copy_assignment
 = __detected_or_t<false_type, __pocca, _Alloc>;







      using propagate_on_container_move_assignment
 = __detected_or_t<false_type, __pocma, _Alloc>;







      using propagate_on_container_swap
 = __detected_or_t<false_type, __pocs, _Alloc>;







      using is_always_equal
 = typename __detected_or_t<is_empty<_Alloc>, __equal, _Alloc>::type;

      template<typename _Tp>
 using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
      template<typename _Tp>
 using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
# 383 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      [[__nodiscard__]] static constexpr pointer
      allocate(_Alloc& __a, size_type __n)
      { return __a.allocate(__n); }
# 398 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      [[__nodiscard__]] static constexpr pointer
      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
      {
 if constexpr (__has_allocate_hint<_Alloc, size_type, const_void_pointer>)
   return __a.allocate(__n, __hint);
 else
   return __a.allocate(__n);
      }
# 415 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      static constexpr void
      deallocate(_Alloc& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 430 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Tp, typename... _Args>

 requires __can_construct<_Alloc, _Tp, _Args...>
 static constexpr void



 construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
 noexcept(_S_nothrow_construct<_Tp, _Args...>())
 {
   if constexpr (__has_construct<_Alloc, _Tp, _Args...>)
     __a.construct(__p, std::forward<_Args>(__args)...);
   else
     std::_Construct(__p, std::forward<_Args>(__args)...);
 }
# 454 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Tp>
 static constexpr void
 destroy(_Alloc& __a, _Tp* __p)
 noexcept(_S_nothrow_destroy<_Tp>())
 {
   if constexpr (__has_destroy<_Alloc, _Tp>)
     __a.destroy(__p);
   else
     std::_Destroy(__p);
 }
# 473 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      static constexpr size_type
      max_size(const _Alloc& __a) noexcept
      {
 if constexpr (__has_max_size<_Alloc>)
   return __a.max_size();
 else


   return __gnu_cxx::__numeric_traits<size_type>::__max
     / sizeof(value_type);
      }
# 493 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      static constexpr _Alloc
      select_on_container_copy_construction(const _Alloc& __rhs)
      {
 if constexpr (__has_soccc<_Alloc>)
   return __rhs.select_on_container_copy_construction();
 else
   return __rhs;
      }

    private:

      template<typename _Tp, typename... _Args>
 static constexpr bool
 _S_nothrow_construct(_Alloc* __a = nullptr, _Tp* __p = nullptr)
 {
   if constexpr (__has_construct<_Alloc, _Tp, _Args...>)
     return noexcept(__a->construct(__p, std::declval<_Args>()...));
   else
     return __is_nothrow_new_constructible<_Tp, _Args...>;
 }

      template<typename _Tp>
 static constexpr bool
 _S_nothrow_destroy(_Alloc* __a = nullptr, _Tp* __p = nullptr)
 {
   if constexpr (__has_destroy<_Alloc, _Tp>)
     return noexcept(__a->destroy(__p));
   else
     return is_nothrow_destructible<_Tp>::value;
 }
# 548 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
    };
#pragma GCC diagnostic pop
# 559 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
  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>>;
# 611 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      [[__nodiscard__,__gnu__::__always_inline__]]
      static constexpr pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 626 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      [[__nodiscard__,__gnu__::__always_inline__]]
      static constexpr pointer
      allocate(allocator_type& __a, size_type __n,
        [[maybe_unused]] const_void_pointer __hint)
      {



 return __a.allocate(__n);

      }
# 646 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      [[__gnu__::__always_inline__]]
      static constexpr void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 662 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Up, typename... _Args>
 [[__gnu__::__always_inline__]]
 static constexpr void
 construct(allocator_type& __a __attribute__((__unused__)),
    _Up* __p, _Args&&... __args)



 noexcept(__is_nothrow_new_constructible<_Up, _Args...>)

 {



   std::construct_at(__p, std::forward<_Args>(__args)...);



 }
# 689 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Up>
 [[__gnu__::__always_inline__]]
 static constexpr void
 destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 {



   std::destroy_at(__p);

 }






      [[__gnu__::__always_inline__]]
      static constexpr size_type
      max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
      {



 return size_t(-1) / sizeof(value_type);

      }






      [[__gnu__::__always_inline__]]
      static constexpr allocator_type
      select_on_container_copy_construction(const allocator_type& __rhs)
      { return __rhs; }
    };
# 736 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
  template<>
    struct allocator_traits<allocator<void>>
    {

      using allocator_type = allocator<void>;


      using value_type = void;


      using pointer = void*;


      using const_pointer = const void*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;


      using propagate_on_container_copy_assignment = false_type;


      using propagate_on_container_move_assignment = true_type;


      using propagate_on_container_swap = false_type;


      using is_always_equal = true_type;

      template<typename _Up>
 using rebind_alloc = allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<allocator<_Up>>;


      static void*
      allocate(allocator_type&, size_type, const void* = nullptr) = delete;


      static void
      deallocate(allocator_type&, void*, size_type) = delete;
# 800 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Up, typename... _Args>
 [[__gnu__::__always_inline__]]
 static constexpr void
 construct(allocator_type&, _Up* __p, _Args&&... __args)
 noexcept(__is_nothrow_new_constructible<_Up, _Args...>)
 { std::_Construct(__p, std::forward<_Args>(__args)...); }
# 814 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
      template<typename _Up>
 [[__gnu__::__always_inline__]]
 static constexpr void
 destroy(allocator_type&, _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 { std::_Destroy(__p); }


      static size_type
      max_size(const allocator_type&) = delete;






      [[__gnu__::__always_inline__]]
      static constexpr allocator_type
      select_on_container_copy_construction(const allocator_type& __rhs)
      { return __rhs; }
    };



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocca =
 typename __traits::propagate_on_container_copy_assignment::type;
      if constexpr (__pocca::value)
 __one = __two;
    }

  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr _Alloc
    __alloc_on_copy(const _Alloc& __a)
    {
      typedef allocator_traits<_Alloc> __traits;
      return __traits::select_on_container_copy_construction(__a);
    }

  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_move(_Alloc& __one, _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocma
 = typename __traits::propagate_on_container_move_assignment::type;
      if constexpr (__pocma::value)
 __one = std::move(__two);
    }

  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_swap(_Alloc& __one, _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocs = typename __traits::propagate_on_container_swap::type;
      if constexpr (__pocs::value)
 {
   using std::swap;
   swap(__one, __two);
 }
    }
#pragma GCC diagnostic pop

  template<typename _Alloc, typename _Tp,
    typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
    typename = void>
    struct __is_alloc_insertable_impl
    : false_type
    { };

  template<typename _Alloc, typename _Tp, typename _ValueT>
    struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
      __void_t<decltype(allocator_traits<_Alloc>::construct(
     std::declval<_Alloc&>(), std::declval<_ValueT*>(),
     std::declval<_Tp>()))>>
    : true_type
    { };




  template<typename _Alloc>
    struct __is_copy_insertable
    : __is_alloc_insertable_impl<_Alloc,
     typename _Alloc::value_type const&>::type
    { };



  template<typename _Tp>
    struct __is_copy_insertable<allocator<_Tp>>
    : is_copy_constructible<_Tp>
    { };





  template<typename _Alloc>
    struct __is_move_insertable
    : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
    { };



  template<typename _Tp>
    struct __is_move_insertable<allocator<_Tp>>
    : is_move_constructible<_Tp>
    { };



  template<typename _Alloc, typename = void>
    struct __is_allocator : false_type { };

  template<typename _Alloc>
    struct __is_allocator<_Alloc,
      __void_t<typename _Alloc::value_type,
        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
    : true_type { };

  template<typename _Alloc>
    using _RequireAllocator
      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

  template<typename _Alloc>
    using _RequireNotAllocator
      = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;


  template<typename _Alloc>
    concept __allocator_like = requires (_Alloc& __a) {
      typename _Alloc::value_type;
      __a.deallocate(__a.allocate(1u), 1u);
    };

  template<typename _Alloc>
    concept __not_allocator_like = !__allocator_like<_Alloc>;







  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_swap
    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };

  template<typename _Alloc>
    struct __alloc_swap<_Alloc, false>
    {
      static void
      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
      {

 if (__one != __two)
   swap(__one, __two);
      }
    };


  template<typename _Tp, bool
    = __or_<is_copy_constructible<typename _Tp::value_type>,
            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
    struct __shrink_to_fit_aux
    { static bool _S_do_it(_Tp&) noexcept { return false; } };

  template<typename _Tp>
    struct __shrink_to_fit_aux<_Tp, true>
    {
      constexpr
      static bool
      _S_do_it(_Tp& __c) noexcept
      {

 try
   {
     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
  __make_move_if_noexcept_iterator(__c.end()),
  __c.get_allocator()).swap(__c);
     return true;
   }
 catch(...)
   { return false; }



      }
    };
# 1023 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/alloc_traits.h" 3
  template<typename _ForwardIterator, typename _Allocator>
    constexpr
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {
      for (; __first != __last; ++__first)



 allocator_traits<_Allocator>::destroy(__alloc,
           std::__addressof(*__first));

    }


  template<typename _ForwardIterator, typename _Tp>
    __attribute__((__always_inline__)) constexpr
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      allocator<_Tp>&)
    {
      std::_Destroy(__first, __last);
    }





}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/alloc_traits.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{






template<typename _Alloc, typename = typename _Alloc::value_type>
  struct __alloc_traits

  : std::allocator_traits<_Alloc>

  {
    typedef _Alloc allocator_type;

    typedef std::allocator_traits<_Alloc> _Base_type;
    typedef typename _Base_type::value_type value_type;
    typedef typename _Base_type::pointer pointer;
    typedef typename _Base_type::const_pointer const_pointer;
    typedef typename _Base_type::size_type size_type;
    typedef typename _Base_type::difference_type difference_type;

    typedef value_type& reference;
    typedef const value_type& const_reference;
    using _Base_type::allocate;
    using _Base_type::deallocate;
    using _Base_type::construct;
    using _Base_type::destroy;
    using _Base_type::max_size;

  private:
    template<typename _Ptr>
      using __is_custom_pointer
 = std::__and_<std::is_same<pointer, _Ptr>,
        std::__not_<std::is_pointer<_Ptr>>>;

  public:

    template<typename _Ptr, typename... _Args>
      [[__gnu__::__always_inline__]]
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
      noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
           std::forward<_Args>(__args)...)))
      {
 _Base_type::construct(__a, std::__to_address(__p),
         std::forward<_Args>(__args)...);
      }


    template<typename _Ptr>
      [[__gnu__::__always_inline__]]
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      destroy(_Alloc& __a, _Ptr __p)
      noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
      { _Base_type::destroy(__a, std::__to_address(__p)); }

    [[__gnu__::__always_inline__]]
    static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
    { return _Base_type::select_on_container_copy_construction(__a); }

    [[__gnu__::__always_inline__]]
    static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b)
    { std::__alloc_on_swap(__a, __b); }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_copy_assign()
    { return _Base_type::propagate_on_container_copy_assignment::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_move_assign()
    { return _Base_type::propagate_on_container_move_assignment::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_swap()
    { return _Base_type::propagate_on_container_swap::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_always_equal()
    { return _Base_type::is_always_equal::value; }

    __attribute__((__always_inline__))
    static constexpr bool _S_nothrow_move()
    { return _S_propagate_on_move_assign() || _S_always_equal(); }

    template<typename _Tp>
      struct rebind
      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
# 182 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/alloc_traits.h" 3
  };


}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functional_hash.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functional_hash.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functional_hash.h" 3
  template<typename _Result, typename _Arg>
    struct __hash_base
    {




    };



  template<typename _Tp> struct __hash_empty_base { };



  template<typename _Tp>
    struct hash;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++14-extensions"
  template<typename _Tp, typename = void>
    constexpr bool __is_hash_enabled_for = false;

  template<typename _Tp>
    constexpr bool
    __is_hash_enabled_for<_Tp,
     __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
      = true;
#pragma GCC diagnostic pop


  template<typename _Tp>
    struct __hash_not_enabled
    {
      __hash_not_enabled(__hash_not_enabled&&) = delete;
      ~__hash_not_enabled() = delete;
    };


  template<typename _Tp, bool = true>
    struct __hash_enum : 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
    : __conditional_t<__is_enum(_Tp), __hash_enum<_Tp>, __hash_not_enabled<_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); }
    };
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/functional_hash.h" 3
  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };



  template<> struct hash<char8_t> : public __hash_base<size_t, char8_t> { size_t operator()(char8_t __val) const noexcept { return static_cast<size_t>(__val); } };



  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
# 204 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
    };
# 297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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
    { };


}
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/numbers" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/numbers" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/numbers" 2 3





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/numbers" 3
namespace numbers
{


  template<typename _Tp>
    using _Enable_if_floating = enable_if_t<is_floating_point_v<_Tp>, _Tp>;



  template<typename _Tp>
    inline constexpr _Tp e_v
      = _Enable_if_floating<_Tp>(2.718281828459045235360287471352662498L);


  template<typename _Tp>
    inline constexpr _Tp log2e_v
      = _Enable_if_floating<_Tp>(1.442695040888963407359924681001892137L);


  template<typename _Tp>
    inline constexpr _Tp log10e_v
      = _Enable_if_floating<_Tp>(0.434294481903251827651128918916605082L);


  template<typename _Tp>
    inline constexpr _Tp pi_v
      = _Enable_if_floating<_Tp>(3.141592653589793238462643383279502884L);


  template<typename _Tp>
    inline constexpr _Tp inv_pi_v
      = _Enable_if_floating<_Tp>(0.318309886183790671537767526745028724L);


  template<typename _Tp>
    inline constexpr _Tp inv_sqrtpi_v
      = _Enable_if_floating<_Tp>(0.564189583547756286948079451560772586L);


  template<typename _Tp>
    inline constexpr _Tp ln2_v
      = _Enable_if_floating<_Tp>(0.693147180559945309417232121458176568L);


  template<typename _Tp>
    inline constexpr _Tp ln10_v
      = _Enable_if_floating<_Tp>(2.302585092994045684017991454684364208L);


  template<typename _Tp>
    inline constexpr _Tp sqrt2_v
      = _Enable_if_floating<_Tp>(1.414213562373095048801688724209698079L);


  template<typename _Tp>
    inline constexpr _Tp sqrt3_v
      = _Enable_if_floating<_Tp>(1.732050807568877293527446341505872367L);


  template<typename _Tp>
    inline constexpr _Tp inv_sqrt3_v
      = _Enable_if_floating<_Tp>(0.577350269189625764509148780501957456L);


  template<typename _Tp>
    inline constexpr _Tp egamma_v
      = _Enable_if_floating<_Tp>(0.577215664901532860606512090082402431L);


  template<typename _Tp>
    inline constexpr _Tp phi_v
      = _Enable_if_floating<_Tp>(1.618033988749894848204586834365638118L);

  inline constexpr double e = e_v<double>;
  inline constexpr double log2e = log2e_v<double>;
  inline constexpr double log10e = log10e_v<double>;
  inline constexpr double pi = pi_v<double>;
  inline constexpr double inv_pi = inv_pi_v<double>;
  inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
  inline constexpr double ln2 = ln2_v<double>;
  inline constexpr double ln10 = ln10_v<double>;
  inline constexpr double sqrt2 = sqrt2_v<double>;
  inline constexpr double sqrt3 = sqrt3_v<double>;
  inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
  inline constexpr double egamma = egamma_v<double>;
  inline constexpr double phi = phi_v<double>;
# 235 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/numbers" 3
}


}

#pragma GCC diagnostic pop
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 2 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


template<typename _Tp>
  struct numeric_limits;

namespace ranges
{
  namespace __detail
  {
    class __max_size_type
    {
    public:
      __max_size_type() = default;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr
 __max_size_type(_Tp __i) noexcept
   : _M_val(__i), _M_msb(__i < 0)
 { }

      constexpr explicit
      __max_size_type(const __max_diff_type& __d) noexcept;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr explicit
 operator _Tp() const noexcept
 { return _M_val; }

      constexpr explicit
      operator bool() const noexcept
      { return _M_val != 0 || _M_msb != 0; }

      constexpr __max_size_type
      operator+() const noexcept
      { return *this; }

      constexpr __max_size_type
      operator~() const noexcept
      { return __max_size_type{~_M_val, !_M_msb}; }

      constexpr __max_size_type
      operator-() const noexcept
      { return operator~() + 1; }

      constexpr __max_size_type&
      operator++() noexcept
      { return *this += 1; }

      constexpr __max_size_type
      operator++(int) noexcept
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr __max_size_type&
      operator--() noexcept
      { return *this -= 1; }

      constexpr __max_size_type
      operator--(int) noexcept
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      constexpr __max_size_type&
      operator+=(const __max_size_type& __r) noexcept
      {
 const auto __sum = _M_val + __r._M_val;
 const bool __overflow = (__sum < _M_val);
 _M_msb = _M_msb ^ __r._M_msb ^ __overflow;
 _M_val = __sum;
 return *this;
      }

      constexpr __max_size_type&
      operator-=(const __max_size_type& __r) noexcept
      { return *this += -__r; }

      constexpr __max_size_type&
      operator*=(__max_size_type __r) noexcept
      {
 constexpr __max_size_type __threshold
   = __rep(1) << (_S_rep_bits / 2 - 1);
 if (_M_val < __threshold && __r < __threshold)


   _M_val = _M_val * __r._M_val;
 else
   {



     const bool __lsb = _M_val & 1;
     const bool __rlsb = __r._M_val & 1;
     *this >>= 1;
     __r >>= 1;
     _M_val = (2 * _M_val * __r._M_val
        + _M_val * __rlsb + __r._M_val * __lsb);
     *this <<= 1;
     *this += __rlsb * __lsb;
   }

 return *this;
      }

      constexpr __max_size_type&
      operator/=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__r != 0)) std::__glibcxx_assert_fail(); } while (false);

 if (!_M_msb && !__r._M_msb) [[likely]]
   _M_val /= __r._M_val;
 else if (_M_msb && __r._M_msb)
   {
     _M_val = (_M_val >= __r._M_val);
     _M_msb = 0;
   }
 else if (!_M_msb && __r._M_msb)
   _M_val = 0;
 else if (_M_msb && !__r._M_msb)
   {




     const auto __orig = *this;
     *this >>= 1;
     _M_val /= __r._M_val;
     *this <<= 1;
     if (__orig - *this * __r >= __r)
       ++_M_val;
   }
 return *this;
      }

      constexpr __max_size_type&
      operator%=(const __max_size_type& __r) noexcept
      {
 if (!_M_msb && !__r._M_msb) [[likely]]
   _M_val %= __r._M_val;
 else
   *this -= (*this / __r) * __r;
 return *this;
      }

      constexpr __max_size_type&
      operator<<=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__r <= _S_rep_bits)) std::__glibcxx_assert_fail(); } while (false);
 if (__r != 0)
   {
     _M_msb = (_M_val >> (_S_rep_bits - __r._M_val)) & 1;

     if (__r._M_val == _S_rep_bits) [[unlikely]]
       _M_val = 0;
     else
       _M_val <<= __r._M_val;
   }
 return *this;
      }

      constexpr __max_size_type&
      operator>>=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__r <= _S_rep_bits)) std::__glibcxx_assert_fail(); } while (false);
 if (__r != 0)
   {
     if (__r._M_val == _S_rep_bits) [[unlikely]]
       _M_val = 0;
     else
       _M_val >>= __r._M_val;

     if (_M_msb) [[unlikely]]
       {
  _M_val |= __rep(1) << (_S_rep_bits - __r._M_val);
  _M_msb = 0;
       }
   }
 return *this;
      }

      constexpr __max_size_type&
      operator&=(const __max_size_type& __r) noexcept
      {
 _M_val &= __r._M_val;
 _M_msb &= __r._M_msb;
 return *this;
      }

      constexpr __max_size_type&
      operator|=(const __max_size_type& __r) noexcept
      {
 _M_val |= __r._M_val;
 _M_msb |= __r._M_msb;
 return *this;
      }

      constexpr __max_size_type&
      operator^=(const __max_size_type& __r) noexcept
      {
 _M_val ^= __r._M_val;
 _M_msb ^= __r._M_msb;
 return *this;
      }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator+=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a + __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator-=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a - __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator*=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a * __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator/=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a / __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator%=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a % __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator&=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a & __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator|=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a | __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator^=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a ^ __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator<<=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a << __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator>>=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a >> __b)); }

      friend constexpr __max_size_type
      operator+(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l += __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator-(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l -= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator*(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l *= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator/(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l /= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator%(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l %= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator<<(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l <<= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator>>(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l >>= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator&(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l &= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator|(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l |= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator^(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l ^= __r;
 return __l;
      }

      friend constexpr bool
      operator==(const __max_size_type& __l, const __max_size_type& __r) noexcept
      { return __l._M_val == __r._M_val && __l._M_msb == __r._M_msb; }


      friend constexpr strong_ordering
      operator<=>(const __max_size_type& __l, const __max_size_type& __r) noexcept
      {
 if (__l._M_msb ^ __r._M_msb)
   return __l._M_msb ? strong_ordering::greater : strong_ordering::less;
 else
   return __l._M_val <=> __r._M_val;
      }
# 422 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 3
      __extension__
      using __rep = unsigned __int128;



      static constexpr size_t _S_rep_bits = sizeof(__rep) * 8;
    private:
      __rep _M_val = 0;
      unsigned _M_msb:1 = 0;

      constexpr explicit
      __max_size_type(__rep __val, int __msb) noexcept
 : _M_val(__val), _M_msb(__msb)
      { }

      friend __max_diff_type;
      friend std::numeric_limits<__max_size_type>;
      friend std::numeric_limits<__max_diff_type>;
    };

    class __max_diff_type
    {
    public:
      __max_diff_type() = default;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr
 __max_diff_type(_Tp __i) noexcept
   : _M_rep(__i)
 { }

      constexpr explicit
      __max_diff_type(const __max_size_type& __d) noexcept
 : _M_rep(__d)
      { }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr explicit
 operator _Tp() const noexcept
 { return static_cast<_Tp>(_M_rep); }

      constexpr explicit
      operator bool() const noexcept
      { return _M_rep != 0; }

      constexpr __max_diff_type
      operator+() const noexcept
      { return *this; }

      constexpr __max_diff_type
      operator-() const noexcept
      { return __max_diff_type(-_M_rep); }

      constexpr __max_diff_type
      operator~() const noexcept
      { return __max_diff_type(~_M_rep); }

      constexpr __max_diff_type&
      operator++() noexcept
      { return *this += 1; }

      constexpr __max_diff_type
      operator++(int) noexcept
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr __max_diff_type&
      operator--() noexcept
      { return *this -= 1; }

      constexpr __max_diff_type
      operator--(int) noexcept
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      constexpr __max_diff_type&
      operator+=(const __max_diff_type& __r) noexcept
      {
 _M_rep += __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator-=(const __max_diff_type& __r) noexcept
      {
 _M_rep -= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator*=(const __max_diff_type& __r) noexcept
      {
 _M_rep *= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator/=(const __max_diff_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__r != 0)) std::__glibcxx_assert_fail(); } while (false);
 const bool __neg = *this < 0;
 const bool __rneg = __r < 0;
 if (!__neg && !__rneg)
   _M_rep = _M_rep / __r._M_rep;
 else if (__neg && __rneg)
   _M_rep = -_M_rep / -__r._M_rep;
 else if (__neg && !__rneg)
   _M_rep = -(-_M_rep / __r._M_rep);
 else
   _M_rep = -(_M_rep / -__r._M_rep);
 return *this ;
      }

      constexpr __max_diff_type&
      operator%=(const __max_diff_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__r != 0)) std::__glibcxx_assert_fail(); } while (false);
 if (*this >= 0 && __r > 0)
   _M_rep %= __r._M_rep;
 else
   *this -= (*this / __r) * __r;
 return *this;
      }

      constexpr __max_diff_type&
      operator<<=(const __max_diff_type& __r) noexcept
      {
 _M_rep.operator<<=(__r._M_rep);
 return *this;
      }

      constexpr __max_diff_type&
      operator>>=(const __max_diff_type& __r) noexcept
      {

 const auto __msb = _M_rep._M_msb;
 _M_rep >>= __r._M_rep;
 if (__msb)
   _M_rep |= ~(__max_size_type(-1) >> __r._M_rep);
 return *this;
      }

      constexpr __max_diff_type&
      operator&=(const __max_diff_type& __r) noexcept
      {
 _M_rep &= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator|=(const __max_diff_type& __r) noexcept
      {
 _M_rep |= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator^=(const __max_diff_type& __r) noexcept
      {
 _M_rep ^= __r._M_rep;
 return *this;
      }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator+=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a + __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator-=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a - __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator*=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a * __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator/=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a / __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator%=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a % __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator&=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a & __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator|=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a | __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator^=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a ^ __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator<<=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a << __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator>>=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a >> __b)); }

      friend constexpr __max_diff_type
      operator+(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l += __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator-(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l -= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator*(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l *= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator/(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l /= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator%(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l %= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator<<(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l <<= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator>>(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l >>= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator&(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l &= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator|(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l |= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator^(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l ^= __r;
 return __l;
      }

      friend constexpr bool
      operator==(const __max_diff_type& __l, const __max_diff_type& __r) noexcept
      { return __l._M_rep == __r._M_rep; }


      constexpr strong_ordering
      operator<=>(const __max_diff_type& __r) const noexcept
      {
 const auto __lsign = _M_rep._M_msb;
 const auto __rsign = __r._M_rep._M_msb;
 if (__lsign ^ __rsign)
   return __lsign ? strong_ordering::less : strong_ordering::greater;
 else
   return _M_rep <=> __r._M_rep;
      }
# 755 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/max_size_type.h" 3
    private:
      __max_size_type _M_rep = 0;

      friend class __max_size_type;
    };

    constexpr
    __max_size_type::__max_size_type(const __max_diff_type& __d) noexcept
      : __max_size_type(__d._M_rep)
    { }

  }
}

  template<>
    struct numeric_limits<ranges::__detail::__max_size_type>
    {
      using _Sp = ranges::__detail::__max_size_type;
      static constexpr bool is_specialized = true;
      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int digits
 = __gnu_cxx::__int_traits<_Sp::__rep>::__digits + 1;
      static constexpr int digits10
 = static_cast<int>(digits * numbers::ln2 / numbers::ln10);

      static constexpr _Sp
      min() noexcept
      { return 0; }

      static constexpr _Sp
      max() noexcept
      { return _Sp(static_cast<_Sp::__rep>(-1), 1); }

      static constexpr _Sp
      lowest() noexcept
      { return min(); }
    };

  template<>
    struct numeric_limits<ranges::__detail::__max_diff_type>
    {
      using _Dp = ranges::__detail::__max_diff_type;
      using _Sp = ranges::__detail::__max_size_type;
      static constexpr bool is_specialized = true;
      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int digits = numeric_limits<_Sp>::digits - 1;
      static constexpr int digits10
 = static_cast<int>(digits * numbers::ln2 / numbers::ln10);

      static constexpr _Dp
      min() noexcept
      { return _Dp(_Sp(0, 1)); }

      static constexpr _Dp
      max() noexcept
      { return _Dp(_Sp(static_cast<_Sp::__rep>(-1), 0)); }

      static constexpr _Dp
      lowest() noexcept
      { return min(); }
    };


}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 2 3





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"








namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  template<typename>
    inline constexpr bool disable_sized_range = false;

  template<typename _Tp>
    inline constexpr bool enable_borrowed_range = false;

  namespace __detail
  {
    constexpr __max_size_type
    __to_unsigned_like(__max_size_type __t) noexcept
    { return __t; }

    constexpr __max_size_type
    __to_unsigned_like(__max_diff_type __t) noexcept
    { return __max_size_type(__t); }

    template<integral _Tp>
      constexpr auto
      __to_unsigned_like(_Tp __t) noexcept
      { return static_cast<make_unsigned_t<_Tp>>(__t); }


    constexpr unsigned __int128
    __to_unsigned_like(__int128 __t) noexcept
    { return __t; }

    constexpr unsigned __int128
    __to_unsigned_like(unsigned __int128 __t) noexcept
    { return __t; }


    template<typename _Tp>
      using __make_unsigned_like_t
 = decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));


    template<typename _Tp>
      concept __maybe_borrowed_range
 = is_lvalue_reference_v<_Tp>
   || enable_borrowed_range<remove_cvref_t<_Tp>>;

  }


  namespace __access
  {
    using std::ranges::__detail::__maybe_borrowed_range;
    using std::__detail::__range_iter_t;

    struct _Begin
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_begin<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().begin()));
   else
     return noexcept(__decay_copy(begin(std::declval<_Tp&>())));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
   || __adl_begin<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_array_v<remove_reference_t<_Tp>>)
     {
       static_assert(is_lvalue_reference_v<_Tp>);
       return __t + 0;
     }
   else if constexpr (__member_begin<_Tp>)
     return __t.begin();
   else
     return begin(__t);
 }
    };

    template<typename _Tp>
      concept __member_end = requires(_Tp& __t)
 {
   { __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>;
 };


    void end() = delete;

    template<typename _Tp>
      concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>;
 };

    struct _End
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_end<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().end()));
   else
     return noexcept(__decay_copy(end(std::declval<_Tp&>())));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires is_bounded_array_v<remove_reference_t<_Tp>>
   || __member_end<_Tp> || __adl_end<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     {
       static_assert(is_lvalue_reference_v<_Tp>);
       return __t + extent_v<remove_reference_t<_Tp>>;
     }
   else if constexpr (__member_end<_Tp>)
     return __t.end();
   else
     return end(__t);
 }
    };

    template<typename _Tp>
      concept __member_rbegin = requires(_Tp& __t)
 {
   { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
 };

    void rbegin() = delete;

    template<typename _Tp>
      concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(rbegin(__t)) } -> input_or_output_iterator;
 };

    template<typename _Tp>
      concept __reversable = requires(_Tp& __t)
 {
   { _Begin{}(__t) } -> bidirectional_iterator;
   { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
 };

    struct _RBegin
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_rbegin<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().rbegin()));
   else if constexpr (__adl_rbegin<_Tp>)
     return noexcept(__decay_copy(rbegin(std::declval<_Tp&>())));
   else
     {
       if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
  {
    using _It = decltype(_End{}(std::declval<_Tp&>()));

    return is_nothrow_copy_constructible_v<_It>;
  }
       else
  return false;
     }
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const
 noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_rbegin<_Tp>)
     return __t.rbegin();
   else if constexpr (__adl_rbegin<_Tp>)
     return rbegin(__t);
   else
     return std::make_reverse_iterator(_End{}(__t));
 }
    };

    template<typename _Tp>
      concept __member_rend = requires(_Tp& __t)
 {
   { __decay_copy(__t.rend()) }
     -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
 };

    void rend() = delete;

    template<typename _Tp>
      concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(rend(__t)) }
     -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
 };

    struct _REnd
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_rend<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().rend()));
   else if constexpr (__adl_rend<_Tp>)
     return noexcept(__decay_copy(rend(std::declval<_Tp&>())));
   else
     {
       if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
  {
    using _It = decltype(_Begin{}(std::declval<_Tp&>()));

    return is_nothrow_copy_constructible_v<_It>;
  }
       else
  return false;
     }
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const
 noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_rend<_Tp>)
     return __t.rend();
   else if constexpr (__adl_rend<_Tp>)
     return rend(__t);
   else
     return std::make_reverse_iterator(_Begin{}(__t));
 }
    };

    template<typename _Tp>
      concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(__t.size()) } -> __detail::__is_integer_like;
 };

    void size() = delete;

    template<typename _Tp>
      concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
 && !disable_sized_range<remove_cvref_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(size(__t)) } -> __detail::__is_integer_like;
 };

    template<typename _Tp>
      concept __sentinel_size = requires(_Tp& __t)
 {
   requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);

   { _Begin{}(__t) } -> forward_iterator;

   { _End{}(__t) } -> sized_sentinel_for<decltype(_Begin{}(__t))>;

   __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
 };

    struct _Size
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_size<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().size()));
   else if constexpr (__adl_size<_Tp>)
     return noexcept(__decay_copy(size(std::declval<_Tp&>())));
   else if constexpr (__sentinel_size<_Tp>)
     return noexcept(_End{}(std::declval<_Tp&>())
       - _Begin{}(std::declval<_Tp&>()));
 }

    public:
      template<typename _Tp>
 requires is_bounded_array_v<remove_reference_t<_Tp>>
   || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return extent_v<remove_reference_t<_Tp>>;
   else if constexpr (__member_size<_Tp>)
     return __t.size();
   else if constexpr (__adl_size<_Tp>)
     return size(__t);
   else if constexpr (__sentinel_size<_Tp>)
     return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
 }
    };

    struct _SSize
    {


      template<typename _Tp>
 requires requires (_Tp& __t) { _Size{}(__t); }
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
 {
   auto __size = _Size{}(__t);
   using __size_type = decltype(__size);

   if constexpr (integral<__size_type>)
     {
       using __gnu_cxx::__int_traits;
       if constexpr (__int_traits<__size_type>::__digits
       < __int_traits<ptrdiff_t>::__digits)
  return static_cast<ptrdiff_t>(__size);
       else
  return static_cast<make_signed_t<__size_type>>(__size);
     }


   else if constexpr (__detail::__is_int128<__size_type>)
     return static_cast<__int128>(__size);

   else
     return __detail::__max_diff_type(__size);
 }
    };

    template<typename _Tp>
      concept __member_empty = requires(_Tp& __t) { bool(__t.empty()); };

    template<typename _Tp>
      concept __size0_empty = requires(_Tp& __t) { _Size{}(__t) == 0; };

    template<typename _Tp>
      concept __eq_iter_empty = requires(_Tp& __t)
 {
   requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);

   { _Begin{}(__t) } -> forward_iterator;

   bool(_Begin{}(__t) == _End{}(__t));
 };

    struct _Empty
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_empty<_Tp>)
     return noexcept(bool(std::declval<_Tp&>().empty()));
   else if constexpr (__size0_empty<_Tp>)
     return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
   else
     return noexcept(bool(_Begin{}(std::declval<_Tp&>())
  == _End{}(std::declval<_Tp&>())));
 }

    public:
      template<typename _Tp>
 requires __member_empty<_Tp> || __size0_empty<_Tp>
   || __eq_iter_empty<_Tp>
 constexpr bool
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_empty<_Tp>)
     return bool(__t.empty());
   else if constexpr (__size0_empty<_Tp>)
     return _Size{}(__t) == 0;
   else
     return bool(_Begin{}(__t) == _End{}(__t));
 }
    };

    template<typename _Tp>
      concept __pointer_to_object = is_pointer_v<_Tp>
        && is_object_v<remove_pointer_t<_Tp>>;

    template<typename _Tp>
      concept __member_data = requires(_Tp& __t)
 {
   { __decay_copy(__t.data()) } -> __pointer_to_object;
 };

    template<typename _Tp>
      concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;

    struct _Data
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_data<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().data()));
   else
     return noexcept(_Begin{}(std::declval<_Tp&>()));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_data<_Tp> || __begin_data<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
 {
   if constexpr (__member_data<_Tp>)
     return __t.data();
   else
     return std::to_address(_Begin{}(__t));
 }
    };

  }

  inline namespace _Cpo
  {
    inline constexpr ranges::__access::_Begin begin{};
    inline constexpr ranges::__access::_End end{};
    inline constexpr ranges::__access::_RBegin rbegin{};
    inline constexpr ranges::__access::_REnd rend{};
    inline constexpr ranges::__access::_Size size{};
    inline constexpr ranges::__access::_SSize ssize{};
    inline constexpr ranges::__access::_Empty empty{};
    inline constexpr ranges::__access::_Data data{};
  }


  template<typename _Tp>
    concept range = requires(_Tp& __t)
      {
 ranges::begin(__t);
 ranges::end(__t);
      };


  template<typename _Tp>
    concept borrowed_range
      = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;

  template<typename _Tp>
    using iterator_t = std::__detail::__range_iter_t<_Tp>;

  template<range _Range>
    using sentinel_t = decltype(ranges::end(std::declval<_Range&>()));
# 542 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
  template<range _Range>
    using range_difference_t = iter_difference_t<iterator_t<_Range>>;

  template<range _Range>
    using range_value_t = iter_value_t<iterator_t<_Range>>;

  template<range _Range>
    using range_reference_t = iter_reference_t<iterator_t<_Range>>;

  template<range _Range>
    using range_rvalue_reference_t
      = iter_rvalue_reference_t<iterator_t<_Range>>;



  template<range _Range>
    using range_common_reference_t
      = iter_common_reference_t<iterator_t<_Range>>;


  template<typename _Tp>
    concept sized_range = range<_Tp>
      && requires(_Tp& __t) { ranges::size(__t); };

  template<sized_range _Range>
    using range_size_t = decltype(ranges::size(std::declval<_Range&>()));

  template<typename _Derived>
    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface;

  namespace __detail
  {
    template<typename _Tp, typename _Up>
      requires (!same_as<_Tp, view_interface<_Up>>)
      void __is_derived_from_view_interface_fn(const _Tp&,
            const view_interface<_Up>&);



    template<typename _Tp>
      concept __is_derived_from_view_interface
 = requires (_Tp __t) { __is_derived_from_view_interface_fn(__t, __t); };
  }


  struct view_base { };


  template<typename _Tp>
    inline constexpr bool enable_view = derived_from<_Tp, view_base>
      || __detail::__is_derived_from_view_interface<_Tp>;


  template<typename _Tp>
    concept view
      = range<_Tp> && movable<_Tp> && enable_view<_Tp>;




  template<typename _Range, typename _Tp>
    concept output_range
      = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;


  template<typename _Tp>
    concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept forward_range
      = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept bidirectional_range
      = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept random_access_range
      = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept contiguous_range
      = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
      && requires(_Tp& __t)
      {
 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
      };


  template<typename _Tp>
    concept common_range
      = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;







  namespace __access
  {
# 662 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
    template<typename _To, typename _Tp>
      constexpr decltype(auto)
      __as_const(_Tp& __t) noexcept
      {
 static_assert(std::is_same_v<_To&, _Tp&>);

 if constexpr (is_lvalue_reference_v<_To>)
   return const_cast<const _Tp&>(__t);
 else
   return static_cast<const _Tp&&>(__t);
      }


    struct _CBegin
    {
# 691 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
      template<typename _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __e) const
 noexcept(noexcept(_Begin{}(__access::__as_const<_Tp>(__e))))
 requires requires { _Begin{}(__access::__as_const<_Tp>(__e)); }
 {
   return _Begin{}(__access::__as_const<_Tp>(__e));
 }

    };

    struct _CEnd final
    {
# 719 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
      template<typename _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __e) const
 noexcept(noexcept(_End{}(__access::__as_const<_Tp>(__e))))
 requires requires { _End{}(__access::__as_const<_Tp>(__e)); }
 {
   return _End{}(__access::__as_const<_Tp>(__e));
 }

    };

    struct _CRBegin
    {
# 747 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
      template<typename _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __e) const
 noexcept(noexcept(_RBegin{}(__access::__as_const<_Tp>(__e))))
 requires requires { _RBegin{}(__access::__as_const<_Tp>(__e)); }
 {
   return _RBegin{}(__access::__as_const<_Tp>(__e));
 }

    };

    struct _CREnd
    {
# 775 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
      template<typename _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __e) const
 noexcept(noexcept(_REnd{}(__access::__as_const<_Tp>(__e))))
 requires requires { _REnd{}(__access::__as_const<_Tp>(__e)); }
 {
   return _REnd{}(__access::__as_const<_Tp>(__e));
 }

    };

    struct _CData
    {
# 798 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
      template<typename _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __e) const
 noexcept(noexcept(_Data{}(__access::__as_const<_Tp>(__e))))
 requires requires { _Data{}(__access::__as_const<_Tp>(__e)); }
 {
   return _Data{}(__access::__as_const<_Tp>(__e));
 }

    };
  }

  inline namespace _Cpo
  {
    inline constexpr ranges::__access::_CBegin cbegin{};
    inline constexpr ranges::__access::_CEnd cend{};
    inline constexpr ranges::__access::_CRBegin crbegin{};
    inline constexpr ranges::__access::_CREnd crend{};
    inline constexpr ranges::__access::_CData cdata{};
  }

  namespace __detail
  {
    template<typename _Tp>
      inline constexpr bool __is_initializer_list = false;

    template<typename _Tp>
      inline constexpr bool __is_initializer_list<initializer_list<_Tp>> = true;
  }


  template<typename _Tp>
    concept viewable_range = range<_Tp>
      && ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
   || (!view<remove_cvref_t<_Tp>>
       && (is_lvalue_reference_v<_Tp>
    || (movable<remove_reference_t<_Tp>>
        && !__detail::__is_initializer_list<remove_cvref_t<_Tp>>))));



  struct __advance_fn final
  {
    template<input_or_output_iterator _It>
      constexpr void
      operator()(_It& __it, iter_difference_t<_It> __n) const
      {
 if constexpr (random_access_iterator<_It>)
   __it += __n;
 else if constexpr (bidirectional_iterator<_It>)
   {
     if (__n > 0)
       {
  do
    {
      ++__it;
    }
  while (--__n);
       }
     else if (__n < 0)
       {
  do
    {
      --__it;
    }
  while (++__n);
       }
   }
 else
   {

     do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
     while (__n-- > 0)
       ++__it;
   }
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      constexpr void
      operator()(_It& __it, _Sent __bound) const
      {
 if constexpr (assignable_from<_It&, _Sent>)
   __it = std::move(__bound);
 else if constexpr (sized_sentinel_for<_Sent, _It>)
   (*this)(__it, __bound - __it);
 else
   {
     while (__it != __bound)
       ++__it;
   }
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      constexpr iter_difference_t<_It>
      operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound) const
      {
 if constexpr (sized_sentinel_for<_Sent, _It>)
   {
     const auto __diff = __bound - __it;

     if (__diff == 0)
       return __n;
     else if (__diff > 0 ? __n >= __diff : __n <= __diff)
       {
  (*this)(__it, __bound);
  return __n - __diff;
       }
     else if (__n != 0) [[likely]]
       {

  do { if (std::__is_constant_evaluated() && !bool((__n < 0) == (__diff < 0))) std::__glibcxx_assert_fail(); } while (false);

  (*this)(__it, __n);
  return 0;
       }
     else
       return 0;
   }
 else if (__it == __bound || __n == 0)
   return __n;
 else if (__n > 0)
   {
     iter_difference_t<_It> __m = 0;
     do
       {
  ++__it;
  ++__m;
       }
     while (__m != __n && __it != __bound);
     return __n - __m;
   }
 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
   {
     iter_difference_t<_It> __m = 0;
     do
       {
  --__it;
  --__m;
       }
     while (__m != __n && __it != __bound);
     return __n - __m;
   }
 else
   {

     do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
     return __n;
   }
      }

    void operator&() const = delete;
  };

  inline constexpr __advance_fn advance{};

  struct __distance_fn final
  {


    template<typename _It, sentinel_for<_It> _Sent>
      requires (!sized_sentinel_for<_Sent, _It>)
      constexpr iter_difference_t<_It>
      operator()[[nodiscard]](_It __first, _Sent __last) const
      {
 iter_difference_t<_It> __n = 0;
 while (__first != __last)
   {
     ++__first;
     ++__n;
   }
 return __n;
      }

    template<typename _It, sized_sentinel_for<decay_t<_It>> _Sent>
      [[nodiscard]]
      constexpr iter_difference_t<decay_t<_It>>
      operator()(_It&& __first, _Sent __last) const
      { return __last - static_cast<const decay_t<_It>&>(__first); }

    template<range _Range>
      [[nodiscard]]
      constexpr range_difference_t<_Range>
      operator()(_Range&& __r) const
      {
 if constexpr (sized_range<_Range>)
   return static_cast<range_difference_t<_Range>>(ranges::size(__r));
 else
   return (*this)(ranges::begin(__r), ranges::end(__r));
      }

    void operator&() const = delete;
  };

  inline constexpr __distance_fn distance{};

  struct __next_fn final
  {
    template<input_or_output_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x) const
      {
 ++__x;
 return __x;
      }

    template<input_or_output_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n) const
      {
 ranges::advance(__x, __n);
 return __x;
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, _Sent __bound) const
      {
 ranges::advance(__x, __bound);
 return __x;
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
      {
 ranges::advance(__x, __n, __bound);
 return __x;
      }

    void operator&() const = delete;
  };

  inline constexpr __next_fn next{};

  struct __prev_fn final
  {
    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x) const
      {
 --__x;
 return __x;
      }

    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n) const
      {
 ranges::advance(__x, -__n);
 return __x;
      }

    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
      {
 ranges::advance(__x, -__n, __bound);
 return __x;
      }

    void operator&() const = delete;
  };

  inline constexpr __prev_fn prev{};


  struct dangling
  {
    constexpr dangling() noexcept = default;
    template<typename... _Args>
      constexpr dangling(_Args&&...) noexcept { }
  };

  template<range _Range>
    using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
      iterator_t<_Range>,
      dangling>;
}
# 1121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_base.h" 3
}

#pragma GCC diagnostic pop
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{



  constexpr size_t
  __sv_check(size_t __size, size_t __pos, const char* __s)
  {
    if (__pos > __size)
      __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)"), __s, __pos, __size);

    return __pos;
  }



  constexpr size_t
  __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept
  {
   const bool __testoff = __off < __size - __pos;
   return __testoff ? __off : __size - __pos;
  }
# 107 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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_trivially_copyable_v<_CharT>
   && is_trivially_default_constructible_v<_CharT>
   && is_standard_layout_v<_CharT>);
      static_assert(is_same_v<_CharT, typename _Traits::char_type>);

    public:


      using traits_type = _Traits;
      using value_type = _CharT;
      using pointer = value_type*;
      using const_pointer = const value_type*;
      using reference = value_type&;
      using const_reference = const value_type&;
      using const_iterator = const value_type*;
      using iterator = const_iterator;
      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
      using reverse_iterator = const_reverse_iterator;
      using size_type = size_t;
      using difference_type = ptrdiff_t;
      static constexpr size_type npos = size_type(-1);



      constexpr
      basic_string_view() noexcept
      : _M_len{0}, _M_str{nullptr}
      { }

      constexpr basic_string_view(const basic_string_view&) noexcept = default;

      [[__gnu__::__nonnull__]]
      constexpr
      basic_string_view(const _CharT* __str) noexcept
      : _M_len{traits_type::length(__str)},
 _M_str{__str}
      { }

      constexpr
      basic_string_view(const _CharT* __str, size_type __len) noexcept
      : _M_len{__len}, _M_str{__str}
      { }


      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
 requires same_as<iter_value_t<_It>, _CharT>
   && (!convertible_to<_End, size_type>)
 constexpr
 basic_string_view(_It __first, _End __last)
 noexcept(noexcept(__last - __first))
 : _M_len(__last - __first), _M_str(std::to_address(__first))
 { }
# 184 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 3
      constexpr basic_string_view&
      operator=(const basic_string_view&) noexcept = default;



      [[nodiscard]]
      constexpr const_iterator
      begin() const noexcept
      { return this->_M_str; }

      [[nodiscard]]
      constexpr const_iterator
      end() const noexcept
      { return this->_M_str + this->_M_len; }

      [[nodiscard]]
      constexpr const_iterator
      cbegin() const noexcept
      { return this->_M_str; }

      [[nodiscard]]
      constexpr const_iterator
      cend() const noexcept
      { return this->_M_str + this->_M_len; }

      [[nodiscard]]
      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }



      [[nodiscard]]
      constexpr size_type
      size() const noexcept
      { return this->_M_len; }

      [[nodiscard]]
      constexpr size_type
      length() const noexcept
      { return _M_len; }

      [[nodiscard]]
      constexpr size_type
      max_size() const noexcept
      {
 return (npos - sizeof(size_type) - sizeof(void*))
  / sizeof(value_type) / 4;
      }

      [[nodiscard]]
      constexpr bool
      empty() const noexcept
      { return this->_M_len == 0; }



      [[nodiscard]]
      constexpr const_reference
      operator[](size_type __pos) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos < this->_M_len)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_str + __pos);
      }

      [[nodiscard]]
      constexpr const_reference
      at(size_type __pos) const
      {
 if (__pos >= _M_len)
   __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size());


 return *(this->_M_str + __pos);
      }

      [[nodiscard]]
      constexpr const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_str;
      }

      [[nodiscard]]
      constexpr const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_str + this->_M_len - 1);
      }

      [[nodiscard]]
      constexpr const_pointer
      data() const noexcept
      { return this->_M_str; }



      constexpr void
      remove_prefix(size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) std::__glibcxx_assert_fail(); } while (false);
 this->_M_str += __n;
 this->_M_len -= __n;
      }

      constexpr void
      remove_suffix(size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) std::__glibcxx_assert_fail(); } while (false);
 this->_M_len -= __n;
      }

      constexpr void
      swap(basic_string_view& __sv) noexcept
      {
 auto __tmp = *this;
 *this = __sv;
 __sv = __tmp;
      }



      constexpr
      size_type
      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
      {
                                          ;
 __pos = std::__sv_check(size(), __pos, "basic_string_view::copy");
 const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);


 traits_type::copy(__str, data() + __pos, __rlen);
 return __rlen;
      }

      [[nodiscard]]
      constexpr basic_string_view
      substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
      {
 __pos = std::__sv_check(size(), __pos, "basic_string_view::substr");
 const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);
 return basic_string_view{_M_str + __pos, __rlen};
      }

      [[nodiscard]]
      constexpr int
      compare(basic_string_view __str) const noexcept
      {
 const size_type __rlen = std::min(this->_M_len, __str._M_len);
 int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
 if (__ret == 0)
   __ret = _S_compare(this->_M_len, __str._M_len);
 return __ret;
      }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
      { return this->substr(__pos1, __n1).compare(__str); }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1,
       basic_string_view __str, size_type __pos2, size_type __n2) const
      {
 return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
      }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr int
      compare(const _CharT* __str) const noexcept
      { return this->compare(basic_string_view{__str}); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr int
      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1,
       const _CharT* __str, size_type __n2) const noexcept(false)
      {
 return this->substr(__pos1, __n1)
     .compare(basic_string_view(__str, __n2));
      }


      [[nodiscard]]
      constexpr bool
      starts_with(basic_string_view __x) const noexcept
      {
 return _M_len >= __x._M_len
   && traits_type::compare(_M_str, __x._M_str, __x._M_len) == 0;
      }

      [[nodiscard]]
      constexpr bool
      starts_with(_CharT __x) const noexcept
      { return !this->empty() && traits_type::eq(this->front(), __x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      starts_with(const _CharT* __x) const noexcept
      { return this->starts_with(basic_string_view(__x)); }

      [[nodiscard]]
      constexpr bool
      ends_with(basic_string_view __x) const noexcept
      {
 const auto __len = this->size();
 const auto __xlen = __x.size();
 return __len >= __xlen
   && traits_type::compare(end() - __xlen, __x.data(), __xlen) == 0;
      }

      [[nodiscard]]
      constexpr bool
      ends_with(_CharT __x) const noexcept
      { return !this->empty() && traits_type::eq(this->back(), __x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      ends_with(const _CharT* __x) const noexcept
      { return this->ends_with(basic_string_view(__x)); }
# 452 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 3
      [[nodiscard]]
      constexpr size_type
      find(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;

      [[nodiscard]]
      constexpr size_type
      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos,
      size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(basic_string_view __str,
     size_type __pos = npos) const noexcept
      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
      { return this->rfind(__c, __pos); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos,
     size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(basic_string_view __str,
   size_type __pos = 0) const noexcept
      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(const _CharT* __str,
   size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
      {
 return this->find_first_not_of(__str, __pos,
           traits_type::length(__str));
      }

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(basic_string_view __str,
         size_type __pos = npos) const noexcept
      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos = npos) const noexcept
      {
 return this->find_last_not_of(__str, __pos,
          traits_type::length(__str));
      }

    private:

      static constexpr int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 using __limits = __gnu_cxx::__int_traits<int>;
 const difference_type __diff = __n1 - __n2;
 if (__diff > __limits::__max)
   return __limits::__max;
 if (__diff < __limits::__min)
   return __limits::__min;
 return static_cast<int>(__diff);
      }

      size_t _M_len;
      const _CharT* _M_str;
    };


  template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
    basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
# 613 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 3
  template<typename _CharT, typename _Traits>
    [[nodiscard]]
    constexpr bool
    operator==(basic_string_view<_CharT, _Traits> __x,
        type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.size() == __y.size() && __x.compare(__y) == 0; }

  template<typename _CharT, typename _Traits>
    [[nodiscard]]
    constexpr auto
    operator<=>(basic_string_view<_CharT, _Traits> __x,
  __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__x.compare(__y)); }
# 765 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        basic_string_view<_CharT,_Traits> __str)
    { return __ostream_insert(__os, __str.data(), __str.size()); }




  using string_view = basic_string_view<char>;
  using wstring_view = basic_string_view<wchar_t>;

  using u8string_view = basic_string_view<char8_t>;

  using u16string_view = basic_string_view<char16_t>;
  using u32string_view = basic_string_view<char32_t>;



  template<typename _Tp>
    struct hash;

  template<>
    struct hash<string_view>
    : public __hash_base<size_t, string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const string_view& __str) const noexcept
      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
    };

  template<>
    struct __is_fast_hash<hash<string_view>> : std::false_type
    { };

  template<>
    struct hash<wstring_view>
    : public __hash_base<size_t, wstring_view>
    {
      [[nodiscard]]
      size_t
      operator()(const wstring_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(wchar_t)); }
    };

  template<>
    struct __is_fast_hash<hash<wstring_view>> : std::false_type
    { };


  template<>
    struct hash<u8string_view>
    : public __hash_base<size_t, u8string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u8string_view& __str) const noexcept
      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
    };

  template<>
    struct __is_fast_hash<hash<u8string_view>> : std::false_type
    { };


  template<>
    struct hash<u16string_view>
    : public __hash_base<size_t, u16string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u16string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char16_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u16string_view>> : std::false_type
    { };

  template<>
    struct hash<u32string_view>
    : public __hash_base<size_t, u32string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u32string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char32_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u32string_view>> : std::false_type
    { };

  inline namespace literals
  {
  inline namespace string_view_literals
  {
#pragma GCC diagnostic push

    inline constexpr basic_string_view<char>
    operator""sv(const char* __str, size_t __len) noexcept
    { return basic_string_view<char>{__str, __len}; }

    inline constexpr basic_string_view<wchar_t>
    operator""sv(const wchar_t* __str, size_t __len) noexcept
    { return basic_string_view<wchar_t>{__str, __len}; }


    inline constexpr basic_string_view<char8_t>
    operator""sv(const char8_t* __str, size_t __len) noexcept
    { return basic_string_view<char8_t>{__str, __len}; }


    inline constexpr basic_string_view<char16_t>
    operator""sv(const char16_t* __str, size_t __len) noexcept
    { return basic_string_view<char16_t>{__str, __len}; }

    inline constexpr basic_string_view<char32_t>
    operator""sv(const char32_t* __str, size_t __len) noexcept
    { return basic_string_view<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop
  }
  }


  namespace ranges
  {

    template<typename _CharT, typename _Traits>
      inline constexpr bool
 enable_borrowed_range<basic_string_view<_CharT, _Traits>> = true;


    template<typename _CharT, typename _Traits>
      inline constexpr bool
 enable_view<basic_string_view<_CharT, _Traits>> = true;
  }


}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/string_view.tcc" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/string_view.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
                                               ;

      if (__n == 0)
 return __pos <= _M_len ? __pos : npos;
      if (__pos >= _M_len)
 return npos;

      const _CharT __elem0 = __str[0];
      const _CharT* __first = _M_str + __pos;
      const _CharT* const __last = _M_str + _M_len;
      size_type __len = _M_len - __pos;

      while (__len >= __n)
 {

   __first = traits_type::find(__first, __len - __n + 1, __elem0);
   if (!__first)
     return npos;



   if (traits_type::compare(__first, __str, __n) == 0)
     return __first - _M_str;
   __len = __last - ++__first;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      if (__pos < this->_M_len)
 {
   const size_type __n = this->_M_len - __pos;
   const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
   if (__p)
     __ret = __p - this->_M_str;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
                                               ;

      if (__n <= this->_M_len)
 {
   __pos = std::min(size_type(this->_M_len - __n), __pos);
   do
     {
       if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size > 0)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(this->_M_str[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_of(const _CharT* __str, size_type __pos,
    size_type __n) const noexcept
    {
                                               ;
      for (; __n && __pos < this->_M_len; ++__pos)
 {
   const _CharT* __p = traits_type::find(__str, __n,
      this->_M_str[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_of(const _CharT* __str, size_type __pos,
   size_type __n) const noexcept
    {
                                               ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(const _CharT* __str, size_type __pos,
        size_type __n) const noexcept
    {
                                               ;
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::find(__str, __n, this->_M_str[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::eq(this->_M_str[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(const _CharT* __str, size_type __pos,
       size_type __n) const noexcept
    {
                                               ;
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(this->_M_str[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }


}
# 912 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string_view" 2 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 2 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {

      static_assert(is_trivially_copyable_v<_CharT>
   && is_trivially_default_constructible_v<_CharT>
   && is_standard_layout_v<_CharT>);
      static_assert(is_same_v<_CharT, typename _Traits::char_type>);
      static_assert(is_same_v<_CharT, typename _Alloc::value_type>);
      using _Char_alloc_type = _Alloc;





      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;


    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Char_alloc_type allocator_type;
      typedef typename _Alloc_traits::size_type size_type;
      typedef typename _Alloc_traits::difference_type difference_type;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
       const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;


      static const size_type npos = static_cast<size_type>(-1);

    protected:




      typedef const_iterator __const_iterator;


    private:
      static constexpr pointer
      _S_allocate(_Char_alloc_type& __a, size_type __n)
      {
 pointer __p = _Alloc_traits::allocate(__a, __n);



 if constexpr (!is_same_v<_Traits, char_traits<_CharT>>)
   if (std::__is_constant_evaluated())

     for (size_type __i = 0; __i < __n; ++__i)
       std::construct_at(__builtin_addressof(__p[__i]));

 return __p;
      }



      typedef basic_string_view<_CharT, _Traits> __sv_type;

      template<typename _Tp, typename _Res>
 using _If_sv = enable_if_t<
   __and_<is_convertible<const _Tp&, __sv_type>,
   __not_<is_convertible<const _Tp*, const basic_string*>>,
   __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
   _Res>;


      constexpr
      static __sv_type
      _S_to_string_view(__sv_type __svt) noexcept
      { return __svt; }





      struct __sv_wrapper
      {
 constexpr explicit
 __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }

 __sv_type _M_sv;
      };







      constexpr
      explicit
      basic_string(__sv_wrapper __svw, const _Alloc& __a)
      : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }



      struct _Alloc_hider : allocator_type
      {




 constexpr
 _Alloc_hider(pointer __dat, const _Alloc& __a)
 : allocator_type(__a), _M_p(__dat) { }

 constexpr
 _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
 : allocator_type(std::move(__a)), _M_p(__dat) { }


 pointer _M_p;
      };

      _Alloc_hider _M_dataplus;
      size_type _M_string_length;

      enum { _S_local_capacity = 15 / sizeof(_CharT) };

      union
      {
 _CharT _M_local_buf[_S_local_capacity + 1];
 size_type _M_allocated_capacity;
      };

      constexpr
      void
      _M_data(pointer __p)
      { _M_dataplus._M_p = __p; }

      constexpr
      void
      _M_length(size_type __length)
      { _M_string_length = __length; }

      constexpr
      pointer
      _M_data() const
      { return _M_dataplus._M_p; }

      constexpr
      pointer
      _M_local_data()
      {

 return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);



      }

      constexpr
      const_pointer
      _M_local_data() const
      {

 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);



      }

      constexpr
      void
      _M_capacity(size_type __capacity)
      { _M_allocated_capacity = __capacity; }

      constexpr
      void
      _M_set_length(size_type __n)
      {
 _M_length(__n);
 traits_type::assign(_M_data()[__n], _CharT());
      }

      constexpr
      bool
      _M_is_local() const
      {
 if (_M_data() == _M_local_data())
   {
     if (_M_string_length > _S_local_capacity)
       __builtin_unreachable();
     return true;
   }
 return false;
      }


      constexpr
      pointer
      _M_create(size_type&, size_type);

      constexpr
      void
      _M_dispose()
      {
 if (!_M_is_local())
   _M_destroy(_M_allocated_capacity);
      }

      constexpr
      void
      _M_destroy(size_type __size) throw()
      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
# 332 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _InIterator>
 constexpr
        void
        _M_construct(_InIterator __beg, _InIterator __end,
       std::input_iterator_tag);



      template<typename _FwdIterator>
 constexpr
        void
        _M_construct(_FwdIterator __beg, _FwdIterator __end,
       std::forward_iterator_tag);

      constexpr
      void
      _M_construct(size_type __req, _CharT __c);



      template<bool _Terminated>
 constexpr
 void
 _M_construct(const _CharT *__c, size_type __n);

      constexpr
      allocator_type&
      _M_get_allocator()
      { return _M_dataplus; }

      constexpr
      const allocator_type&
      _M_get_allocator() const
      { return _M_dataplus; }


      __attribute__((__always_inline__))
      constexpr
      void
      _M_init_local_buf() noexcept
      {

 if (std::is_constant_evaluated())
   for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
     _M_local_buf[__i] = _CharT();

      }

      __attribute__((__always_inline__))
      constexpr
      pointer
      _M_use_local_data() noexcept
      {

 _M_init_local_buf();

 return _M_local_data();
      }

    private:
# 407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),

       __s, __pos, this->size());
 return __pos;
      }

      constexpr
      void
      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error((__s));
      }



      constexpr
      size_type
      _M_limit(size_type __pos, size_type __off) const noexcept
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }


      bool
      _M_disjunct(const _CharT* __s) const noexcept
      {
 return (less<const _CharT*>()(__s, _M_data())
  || less<const _CharT*>()(_M_data() + this->size(), __s));
      }



      constexpr
      static void
      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::copy(__d, __s, __n);
      }

      constexpr
      static void
      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::move(__d, __s, __n);
      }

      constexpr
      static void
      _S_assign(_CharT* __d, size_type __n, _CharT __c)
      {
 if (__n == 1)
   traits_type::assign(*__d, __c);
 else
   traits_type::assign(__d, __n, __c);
      }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"


      template<class _Iterator>
 constexpr
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {

   using _IterBase = decltype(std::__niter_base(__k1));
   if constexpr (__or_<is_same<_IterBase, _CharT*>,
         is_same<_IterBase, const _CharT*>>::value)
     _S_copy(__p, std::__niter_base(__k1), __k2 - __k1);

   else if constexpr (requires {
          requires contiguous_iterator<_Iterator>;
          { std::to_address(__k1) }
     -> convertible_to<const _CharT*>;
        })
     {
       const auto __d = __k2 - __k1;
       (void) (__k1 + __d);
       _S_copy(__p, std::to_address(__k1), static_cast<size_type>(__d));
     }

   else

   for (; __k1 != __k2; ++__k1, (void)++__p)
     traits_type::assign(*__p, static_cast<_CharT>(*__k1));
 }
#pragma GCC diagnostic pop
# 549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      static int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 const difference_type __d = difference_type(__n1 - __n2);

 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
   return __gnu_cxx::__numeric_traits<int>::__max;
 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
   return __gnu_cxx::__numeric_traits<int>::__min;
 else
   return int(__d);
      }

      constexpr
      void
      _M_assign(const basic_string&);

      constexpr
      void
      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
  size_type __len2);

      constexpr
      void
      _M_erase(size_type __pos, size_type __n);

    public:







      constexpr
      basic_string()
      noexcept(is_nothrow_default_constructible<_Alloc>::value)

      requires is_default_constructible_v<_Alloc>

      : _M_dataplus(_M_local_data())
      {
 _M_init_local_buf();
 _M_set_length(0);
      }




      constexpr
      explicit
      basic_string(const _Alloc& __a) noexcept
      : _M_dataplus(_M_local_data(), __a)
      {
 _M_init_local_buf();
 _M_set_length(0);
      }





      constexpr
      basic_string(const basic_string& __str)
      : _M_dataplus(_M_local_data(),
      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
      {
 _M_construct<true>(__str._M_data(), __str.length());
      }
# 628 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, npos),
       std::forward_iterator_tag());
      }







      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     size_type __n)
      : _M_dataplus(_M_local_data())
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n),
       std::forward_iterator_tag());
      }
# 663 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     size_type __n, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start
   = __str._M_data() + __str._M_check(__pos, "string::string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n),
       std::forward_iterator_tag());
      }
# 683 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string(const _CharT* __s, size_type __n,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {

 if (__s == 0 && __n > 0)
   std::__throw_logic_error(("basic_string: " "construction from null is not valid"));

 _M_construct(__s, __s + __n, std::forward_iterator_tag());
      }
# 703 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      constexpr
      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {

 if (__s == 0)
   std::__throw_logic_error(("basic_string: " "construction from null is not valid"));

 const _CharT* __end = __s + traits_type::length(__s);
 _M_construct(__s, __end, forward_iterator_tag());
      }
# 726 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      constexpr
      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__n, __c); }
# 741 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string(basic_string&& __str) noexcept
      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
      {
 if (__str._M_is_local())
   {
     _M_init_local_buf();
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         __str.length() + 1);
   }
 else
   {
     _M_data(__str._M_data());
     _M_capacity(__str._M_allocated_capacity);
   }




 _M_length(__str.length());
 __str._M_data(__str._M_use_local_data());
 __str._M_set_length(0);
      }
# 797 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); }

      constexpr
      basic_string(const basic_string& __str, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); }

      constexpr
      basic_string(basic_string&& __str, const _Alloc& __a)
      noexcept(_Alloc_traits::_S_always_equal())
      : _M_dataplus(_M_local_data(), __a)
      {
 if (__str._M_is_local())
   {
     _M_init_local_buf();
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         __str.length() + 1);
     _M_length(__str.length());
     __str._M_set_length(0);
   }
 else if (_Alloc_traits::_S_always_equal()
     || __str.get_allocator() == __a)
   {
     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     __str._M_data(__str._M_use_local_data());
     __str._M_set_length(0);
   }
 else
   _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag());
      }
# 846 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>



 constexpr
        basic_string(_InputIterator __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc())
 : _M_dataplus(_M_local_data(), __a), _M_string_length(0)
 {

   _M_construct(__beg, __end, std::__iterator_category(__beg));




 }
# 872 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp,
        typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
 constexpr
 basic_string(const _Tp& __t, size_type __pos, size_type __n,
       const _Alloc& __a = _Alloc())
 : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }






      template<typename _Tp, typename = _If_sv<_Tp, void>>
 constexpr
 explicit
 basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
 : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }





      constexpr
      ~basic_string()
      { _M_dispose(); }





      constexpr
      basic_string&
      operator=(const basic_string& __str)
      {
 return this->assign(__str);
      }





      constexpr
      basic_string&
      operator=(const _CharT* __s)
      { return this->assign(__s); }
# 925 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 943 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator=(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {
 const bool __equal_allocs = _Alloc_traits::_S_always_equal()
   || _M_get_allocator() == __str._M_get_allocator();
 if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
     && !__equal_allocs)
   {

     _M_destroy(_M_allocated_capacity);
     _M_data(_M_local_data());
     _M_set_length(0);
   }

 std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());

 if (__str._M_is_local())
   {



     if (__builtin_expect(std::__addressof(__str) != this, true))
       {
  if (__str.size())
    this->_S_copy(_M_data(), __str._M_data(), __str.size());
  _M_set_length(__str.size());
       }
   }
 else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs)
   {

     pointer __data = nullptr;
     size_type __capacity;
     if (!_M_is_local())
       {
  if (__equal_allocs)
    {

      __data = _M_data();
      __capacity = _M_allocated_capacity;
    }
  else
    _M_destroy(_M_allocated_capacity);
       }

     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     if (__data)
       {
  __str._M_data(__data);
  __str._M_capacity(__capacity);
       }
     else
       __str._M_data(__str._M_use_local_data());
   }
 else
   _M_assign(__str);
 __str.clear();
 return *this;
      }





      constexpr
      basic_string&
      operator=(initializer_list<_CharT> __l)
      {
 this->assign(__l.begin(), __l.size());
 return *this;
      }







     template<typename _Tp>
       constexpr
       _If_sv<_Tp, basic_string&>
       operator=(const _Tp& __svt)
       { return this->assign(__svt); }





      constexpr
      operator __sv_type() const noexcept
      { return __sv_type(data(), size()); }







      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(_M_data()); }





      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(_M_data()); }





      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return iterator(_M_data() + this->size()); }





      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return const_iterator(_M_data() + this->size()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->begin()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }






      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_data()); }





      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_data() + this->size()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }


    public:



      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      {
 size_type __sz = _M_string_length;
 if (__sz > max_size ())
   __builtin_unreachable ();
 return __sz;
      }



      [[__nodiscard__]] constexpr
      size_type
      length() const noexcept
      { return size(); }


      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      {
 const size_t __diffmax
   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_CharT);
 const size_t __allocmax = _Alloc_traits::max_size(_M_get_allocator());
 return (std::min)(__diffmax, __allocmax) - 1;
      }
# 1199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      void
      resize(size_type __n, _CharT __c);
# 1213 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      constexpr
      void
      shrink_to_fit() noexcept
      { reserve(); }
#pragma GCC diagnostic pop
# 1266 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Operation>
 constexpr void
 __resize_and_overwrite(size_type __n, _Operation __op);






      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      {
 size_t __sz = _M_is_local() ? size_type(_S_local_capacity)
         : _M_allocated_capacity;
 if (__sz < _S_local_capacity || __sz > max_size ())
   __builtin_unreachable ();
 return __sz;
      }
# 1303 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      void
      reserve(size_type __res_arg);





      [[deprecated("use shrink_to_fit() instead")]]

      constexpr
      void
      reserve();




      constexpr
      void
      clear() noexcept
      { _M_set_length(0); }





      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return _M_string_length == 0; }
# 1345 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      operator[] (size_type __pos) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) std::__glibcxx_assert_fail(); } while (false);
 return _M_data()[__pos];
      }
# 1363 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __pos)
      {


 do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) std::__glibcxx_assert_fail(); } while (false);

                                                                   ;
 return _M_data()[__pos];
      }
# 1385 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
 return _M_data()[__n];
      }
# 1407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
 return _M_data()[__n];
      }






      [[__nodiscard__]] constexpr
      reference
      front() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return operator[](0);
      }





      [[__nodiscard__]] constexpr
      const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return operator[](0);
      }





      [[__nodiscard__]] constexpr
      reference
      back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return operator[](this->size() - 1);
      }





      [[__nodiscard__]] constexpr
      const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return operator[](this->size() - 1);
      }
# 1475 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator+=(const basic_string& __str)
      { return this->append(__str); }






      constexpr
      basic_string&
      operator+=(const _CharT* __s)
      { return this->append(__s); }






      constexpr
      basic_string&
      operator+=(_CharT __c)
      {
 this->push_back(__c);
 return *this;
      }







      constexpr
      basic_string&
      operator+=(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1521 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 operator+=(const _Tp& __svt)
 { return this->append(__svt); }







      constexpr
      basic_string&
      append(const basic_string& __str)
      { return this->append(__str._M_data(), __str.size()); }
# 1551 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return this->append(__str._M_data()
       + __str._M_check(__pos, "basic_string::append"),
       __str._M_limit(__pos, __n)); }







      constexpr
      basic_string&
      append(const _CharT* __s, size_type __n)
      {
                                        ;
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }






      constexpr
      basic_string&
      append(const _CharT* __s)
      {
                               ;
 const size_type __n = traits_type::length(__s);
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }
# 1596 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      append(size_type __n, _CharT __c)
      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
# 1659 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      append(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1674 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr



        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(end(), end(), __first, __last); }







      template<typename _Tp>
 constexpr
        _If_sv<_Tp, basic_string&>
        append(const _Tp& __svt)
        {
          __sv_type __sv = __svt;
          return this->append(__sv.data(), __sv.size());
        }
# 1706 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
        _If_sv<_Tp, basic_string&>
 append(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_append(__sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }






      constexpr
      void
      push_back(_CharT __c)
      {
 const size_type __size = this->size();
 if (__size + 1 > this->capacity())
   this->_M_mutate(__size, size_type(0), 0, size_type(1));
 traits_type::assign(this->_M_data()[__size], __c);
 this->_M_set_length(__size + 1);
      }






      constexpr
      basic_string&
      assign(const basic_string& __str)
      {

 if (_Alloc_traits::_S_propagate_on_copy_assign())
   {
     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
  && _M_get_allocator() != __str._M_get_allocator())
       {


  if (__str.size() <= _S_local_capacity)
    {
      _M_destroy(_M_allocated_capacity);
      _M_data(_M_use_local_data());
      _M_set_length(0);
    }
  else
    {
      const auto __len = __str.size();
      auto __alloc = __str._M_get_allocator();

      auto __ptr = _S_allocate(__alloc, __len + 1);
      _M_destroy(_M_allocated_capacity);
      _M_data(__ptr);
      _M_capacity(__len);
      _M_set_length(__len);
    }
       }
     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
   }

 this->_M_assign(__str);
 return *this;
      }
# 1784 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {


 return *this = std::move(__str);
      }
# 1808 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return _M_replace(size_type(0), this->size(), __str._M_data()
     + __str._M_check(__pos, "basic_string::assign"),
     __str._M_limit(__pos, __n)); }
# 1825 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const _CharT* __s, size_type __n)
      {
                                        ;
 return _M_replace(size_type(0), this->size(), __s, __n);
      }
# 1842 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const _CharT* __s)
      {
                               ;
 return _M_replace(size_type(0), this->size(), __s,
     traits_type::length(__s));
      }
# 1860 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1874 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 basic_string&
 assign(_InputIterator __first, _InputIterator __last)
 {
   using _IterTraits = iterator_traits<_InputIterator>;
   if constexpr (is_pointer<decltype(std::__niter_base(__first))>::value
     && is_same<typename _IterTraits::value_type,
         _CharT>::value)
     {
                                                      ;
       return _M_replace(size_type(0), size(),
    std::__niter_base(__first), __last - __first);
     }

   else if constexpr (contiguous_iterator<_InputIterator>
          && is_same_v<iter_value_t<_InputIterator>,
         _CharT>)
     {
                                                      ;
       return _M_replace(size_type(0), size(),
    std::to_address(__first), __last - __first);
     }

   else
     return *this = basic_string(__first, __last, get_allocator());
 }
#pragma GCC diagnostic pop
# 1937 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(initializer_list<_CharT> __l)
      {


 const size_type __n = __l.size();
 if (__n > capacity())
   *this = basic_string(__l.begin(), __l.end(), get_allocator());
 else
   {
     if (__n)
       _S_copy(_M_data(), __l.begin(), __n);
     _M_set_length(__n);
   }
 return *this;
      }
# 1962 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->assign(__sv.data(), __sv.size());
 }
# 1978 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_replace(size_type(0), this->size(),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }
# 2007 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      iterator
      insert(const_iterator __p, size_type __n, _CharT __c)
      {
                                                         ;
 const size_type __pos = __p - begin();
 this->replace(__p, __p, __n, __c);
 return iterator(this->_M_data() + __pos);
      }
# 2050 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
        {
                                                           ;
   const size_type __pos = __p - begin();
   this->replace(__p, __p, __beg, __end);
   return iterator(this->_M_data() + __pos);
 }
# 2118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      iterator
      insert(const_iterator __p, initializer_list<_CharT> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 2146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->replace(__pos1, size_type(0),
        __str._M_data(), __str.size()); }
# 2170 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos1, const basic_string& __str,
      size_type __pos2, size_type __n = npos)
      { return this->replace(__pos1, size_type(0), __str._M_data()
        + __str._M_check(__pos2, "basic_string::insert"),
        __str._M_limit(__pos2, __n)); }
# 2194 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n)
      { return this->replace(__pos, size_type(0), __s, __n); }
# 2214 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
                               ;
 return this->replace(__pos, size_type(0), __s,
        traits_type::length(__s));
      }
# 2239 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
         size_type(0), __n, __c); }
# 2258 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      iterator
      insert(__const_iterator __p, _CharT __c)
      {
                                                         ;
 const size_type __pos = __p - begin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 return iterator(_M_data() + __pos);
      }
# 2275 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->insert(__pos, __sv.data(), __sv.size());
 }
# 2292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos1, const _Tp& __svt,
        size_type __pos2, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, size_type(0),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
       std::__sv_limit(__sv.size(), __pos2, __n));
 }
# 2321 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
 _M_check(__pos, "basic_string::erase");
 if (__n == npos)
   this->_M_set_length(__pos);
 else if (__n != 0)
   this->_M_erase(__pos, _M_limit(__pos, __n));
 return *this;
      }
# 2341 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      iterator
      erase(__const_iterator __position)
      {

                           ;
 const size_type __pos = __position - begin();
 this->_M_erase(__pos, size_type(1));
 return iterator(_M_data() + __pos);
      }
# 2361 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      iterator
      erase(__const_iterator __first, __const_iterator __last)
      {

                        ;
        const size_type __pos = __first - begin();
 if (__last == end())
   this->_M_set_length(__pos);
 else
   this->_M_erase(__pos, __last - __first);
 return iterator(this->_M_data() + __pos);
      }







      constexpr
      void
      pop_back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 _M_erase(size() - 1, 1);
      }
# 2407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 2430 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos)
      { return this->replace(__pos1, __n1, __str._M_data()
        + __str._M_check(__pos2, "basic_string::replace"),
        __str._M_limit(__pos2, __n2)); }
# 2456 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2)
      {
                                         ;
 return _M_replace(_M_check(__pos, "basic_string::replace"),
     _M_limit(__pos, __n1), __s, __n2);
      }
# 2482 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
                               ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 2507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
         _M_limit(__pos, __n1), __n2, __c); }
# 2526 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 2547 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __s, size_type __n)
      {

                      ;
 return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
      }
# 2570 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
      {
                               ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 2592 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
       _CharT __c)
      {

                      ;
 return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
      }
# 2618 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
        basic_string&
        replace(const_iterator __i1, const_iterator __i2,
  _InputIterator __k1, _InputIterator __k2)
        {

                        ;
                                             ;
   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
        std::__false_type());
 }
# 2651 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       _CharT* __k1, _CharT* __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __k1, const _CharT* __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       iterator __k1, iterator __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const_iterator __k1, const_iterator __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }
# 2738 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      basic_string& replace(const_iterator __i1, const_iterator __i2,
       initializer_list<_CharT> __l)
      { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
# 2752 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos, size_type __n, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos, __n, __sv.data(), __sv.size());
 }
# 2770 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, __n1,
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
       std::__sv_limit(__sv.size(), __pos2, __n2));
 }
# 2792 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__i1 - begin(), __i2 - __i1, __sv);
 }


    private:
      template<class _Integer>
 constexpr
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _Integer __n, _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 constexpr
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _InputIterator __k1, _InputIterator __k2,
       __false_type);

      constexpr
      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c);

      __attribute__((__noinline__, __noclone__, __cold__)) void
      _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
        const size_type __len2, const size_type __how_much);

      constexpr
      basic_string&
      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
   const size_type __len2);

      constexpr
      basic_string&
      _M_append(const _CharT* __s, size_type __n);

    public:
# 2849 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 2860 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      constexpr
      void
      swap(basic_string& __s) noexcept;
# 2871 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const _CharT*
      c_str() const noexcept
      { return _M_data(); }
# 2884 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const _CharT*
      data() const noexcept
      { return _M_data(); }
# 2896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      _CharT*
      data() noexcept
      { return _M_data(); }





      [[__nodiscard__]] constexpr
      allocator_type
      get_allocator() const noexcept
      { return _M_get_allocator(); }
# 2922 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2937 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find(__str.data(), __pos, __str.size()); }
# 2950 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find(__sv.data(), __pos, __sv.size());
 }
# 2971 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const _CharT* __s, size_type __pos = 0) const noexcept
      {
                               ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 2989 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;
# 3003 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->rfind(__str.data(), __pos, __str.size()); }
# 3016 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 rfind(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->rfind(__sv.data(), __pos, __sv.size());
 }
# 3039 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 3054 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
                               ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 3072 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 3087 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 3101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_first_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_of(__sv.data(), __pos, __sv.size());
 }
# 3124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 3139 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
                               ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 3160 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }
# 3176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 3190 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_last_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_of(__sv.data(), __pos, __sv.size());
 }
# 3213 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 3228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
                               ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 3249 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
      { return this->rfind(__c, __pos); }
# 3264 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 3278 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_not_of(__sv.data(), __pos, __sv.size());
 }
# 3301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const noexcept;
# 3316 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
                               ;
 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
      }
# 3335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
      noexcept;
# 3351 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 3365 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_not_of(__sv.data(), __pos, __sv.size());
 }
# 3388 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const noexcept;
# 3403 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
                               ;
 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
      }
# 3422 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
      noexcept;
# 3439 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 3459 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }







      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   const size_type __size = this->size();
   const size_type __osize = __sv.size();
   const size_type __len = std::min(__size, __osize);

   int __r = traits_type::compare(_M_data(), __sv.data(), __len);
   if (!__r)
     __r = _S_compare(__size, __osize);
   return __r;
 }
# 3504 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(size_type __pos, size_type __n, const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this).substr(__pos, __n).compare(__sv);
 }
# 3524 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this)
     .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
 }
# 3556 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const
      {
 _M_check(__pos, "basic_string::compare");
 __n = _M_limit(__pos, __n);
 const size_type __osize = __str.size();
 const size_type __len = std::min(__n, __osize);
 int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
 if (!__r)
   __r = _S_compare(__n, __osize);
 return __r;
      }
# 3593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos) const
      {
 _M_check(__pos1, "basic_string::compare");
 __str._M_check(__pos2, "basic_string::compare");
 __n1 = _M_limit(__pos1, __n1);
 __n2 = __str._M_limit(__pos2, __n2);
 const size_type __len = std::min(__n1, __n2);
 int __r = traits_type::compare(_M_data() + __pos1,
           __str.data() + __pos2, __len);
 if (!__r)
   __r = _S_compare(__n1, __n2);
 return __r;
      }
# 3624 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(const _CharT* __s) const noexcept
      {
                               ;
 const size_type __size = this->size();
 const size_type __osize = traits_type::length(__s);
 const size_type __len = std::min(__size, __osize);
 int __r = traits_type::compare(_M_data(), __s, __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }
# 3659 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const
      {
                               ;
 _M_check(__pos, "basic_string::compare");
 __n1 = _M_limit(__pos, __n1);
 const size_type __osize = traits_type::length(__s);
 const size_type __len = std::min(__n1, __osize);
 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
 if (!__r)
   __r = _S_compare(__n1, __osize);
 return __r;
      }
# 3698 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const
      {
                                         ;
 _M_check(__pos, "basic_string::compare");
 __n1 = _M_limit(__pos, __n1);
 const size_type __len = std::min(__n1, __n2);
 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
 if (!__r)
   __r = _S_compare(__n1, __n2);
 return __r;
      }


      [[nodiscard]]
      constexpr bool
      starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard]]
      constexpr bool
      starts_with(_CharT __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      starts_with(const _CharT* __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard]]
      constexpr bool
      ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }

      [[nodiscard]]
      constexpr bool
      ends_with(_CharT __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      ends_with(const _CharT* __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }
# 3763 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
      template<typename, typename, typename> friend class basic_stringbuf;
    };
}

}


namespace std __attribute__ ((__visibility__ ("default")))
{



namespace __cxx11 {
  template<typename _InputIterator, typename _CharT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;



  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;

  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;
# 3809 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
}


  template<typename _Str>
    constexpr
    inline _Str
    __str_concat(typename _Str::value_type const* __lhs,
   typename _Str::size_type __lhs_len,
   typename _Str::value_type const* __rhs,
   typename _Str::size_type __rhs_len,
   typename _Str::allocator_type const& __a)
    {
      typedef typename _Str::allocator_type allocator_type;
      typedef __gnu_cxx::__alloc_traits<allocator_type> _Alloc_traits;
      _Str __str(_Alloc_traits::_S_select_on_copy(__a));
      __str.reserve(__lhs_len + __rhs_len);
      __str.append(__lhs, __lhs_len);
      __str.append(__rhs, __rhs_len);
      return __str;
    }
# 3837 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __rhs.c_str(), __rhs.size(),
         __lhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
                                      ;
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs),
         __rhs.c_str(), __rhs.size(),
         __rhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1,
         __rhs.c_str(), __rhs.size(),
         __rhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    {
                                      ;
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __rhs, _Traits::length(__rhs),
         __lhs.get_allocator());
    }






  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __builtin_addressof(__rhs), 1,
         __lhs.get_allocator());
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    {

      using _Alloc_traits = allocator_traits<_Alloc>;
      bool __use_rhs = false;
      if constexpr (typename _Alloc_traits::is_always_equal{})
 __use_rhs = true;
      else if (__lhs.get_allocator() == __rhs.get_allocator())
 __use_rhs = true;
      if (__use_rhs)

 {
   const auto __size = __lhs.size() + __rhs.size();
   if (__size > __lhs.capacity() && __size <= __rhs.capacity())
     return std::move(__rhs.insert(0, __lhs));
 }
      return std::move(__lhs.append(__rhs));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, 1, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const _CharT* __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       _CharT __rhs)
    { return std::move(__lhs.append(1, __rhs)); }
# 4042 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    {
      return __lhs.size() == __rhs.size()
        && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    {
      return __lhs.size() == _Traits::length(__rhs)
        && !_Traits::compare(__lhs.data(), __rhs, __lhs.size());
    }
# 4077 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[nodiscard]]
    constexpr auto
    operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
  const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 4092 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[nodiscard]]
    constexpr auto
    operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
  const _CharT* __rhs) noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 4326 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
  basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }
# 4347 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 4365 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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());
    }
# 4388 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 4405 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/string_conversions.h" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/string_conversions.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 1 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

# 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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_wchar_t.h" 1 3 4
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 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
# 58 "/usr/include/stdlib.h" 3 4
typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;





__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ;



extern double atof (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;



__extension__ extern long long int atoll (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;



extern double strtod (const char *__restrict __nptr,
        char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern float strtof (const char *__restrict __nptr,
       char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 140 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
     char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern _Float64 strtof64 (const char *__restrict __nptr,
     char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 158 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern _Float64x strtof64x (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



__extension__
extern long long int strtoq (const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoll (const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int strfromd (char *__dest, size_t __size, const char *__format,
       double __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));

extern int strfromf (char *__dest, size_t __size, const char *__format,
       float __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));

extern int strfroml (char *__dest, size_t __size, const char *__format,
       long double __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 232 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
         _Float32 __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));



extern int strfromf64 (char *__dest, size_t __size, const char * __format,
         _Float64 __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 250 "/usr/include/stdlib.h" 3 4
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
   _Float32x __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));



extern int strfromf64x (char *__dest, size_t __size, const char * __format,
   _Float64x __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 274 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 316 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64 strtof64_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 337 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64x strtof64x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 360 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
 atoi (const char *__nptr) noexcept (true)
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
 atol (const char *__nptr) noexcept (true)
{
  return strtol (__nptr, (char **) __null, 10);
}


__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
 atoll (const char *__nptr) noexcept (true)
{
  return strtoll (__nptr, (char **) __null, 10);
}
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) noexcept (true) ;


extern long int a64l (const char *__s)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;




# 1 "/usr/include/sys/types.h" 1 3 4
# 27 "/usr/include/sys/types.h" 3 4
extern "C" {





typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;


typedef __loff_t loff_t;




typedef __ino_t ino_t;






typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;





typedef __off_t off_t;






typedef __off64_t off64_t;
# 103 "/usr/include/sys/types.h" 3 4
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;
# 134 "/usr/include/sys/types.h" 3 4
typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 145 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;




# 1 "/usr/include/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/sys/types.h" 2 3 4


typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;


typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 33 "/usr/include/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{



  return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8)));

}






static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{



  return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24));

}
# 69 "/usr/include/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{



  return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56));

}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/bits/uintn-identity.h" 3 4
static __inline __uint16_t
__uint16_identity (__uint16_t __x)
{
  return __x;
}

static __inline __uint32_t
__uint32_identity (__uint32_t __x)
{
  return __x;
}

static __inline __uint64_t
__uint64_identity (__uint64_t __x)
{
  return __x;
}
# 37 "/usr/include/endian.h" 2 3 4
# 177 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/select.h" 1 3 4
# 30 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4






typedef __sigset_t sigset_t;
# 34 "/usr/include/sys/select.h" 2 3 4
# 49 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 59 "/usr/include/sys/select.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 91 "/usr/include/sys/select.h" 3 4
extern "C" {
# 102 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 127 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);
# 153 "/usr/include/sys/select.h" 3 4
}
# 180 "/usr/include/sys/types.h" 2 3 4





typedef __blksize_t blksize_t;






typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 219 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 230 "/usr/include/sys/types.h" 3 4
}
# 395 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) noexcept (true);


extern void srandom (unsigned int __seed) noexcept (true);





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     noexcept (true) __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern int rand (void) noexcept (true);

extern void srand (unsigned int __seed) noexcept (true);



extern int rand_r (unsigned int *__seed) noexcept (true);







extern double drand48 (void) noexcept (true);
extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) noexcept (true);
extern long int nrand48 (unsigned short int __xsubi[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) noexcept (true);
extern long int jrand48 (unsigned short int __xsubi[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) noexcept (true);
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    __extension__ unsigned long long int __a;

  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     noexcept (true) __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                         ;

extern void *calloc (size_t __nmemb, size_t __size)
     noexcept (true) __attribute__ ((__malloc__)) ;






extern void *realloc (void *__ptr, size_t __size)
     noexcept (true) __attribute__ ((__warn_unused_result__)) ;


extern void free (void *__ptr) noexcept (true);







extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     noexcept (true) __attribute__ ((__warn_unused_result__))

                       ;


extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     noexcept (true) ;



# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 25 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) noexcept (true);





}
# 574 "/usr/include/stdlib.h" 2 3 4





extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                         ;




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern void *aligned_alloc (size_t __alignment, size_t __size)
     noexcept (true) __attribute__ ((__malloc__)) ;



extern void abort (void) noexcept (true) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern "C++" int at_quick_exit (void (*__func) (void))
     noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 615 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__));





extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__));





extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__));




extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern char *secure_getenv (const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;






extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int setenv (const char *__name, const char *__value, int __replace)
     noexcept (true) __attribute__ ((__nonnull__ (2)));


extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int clearenv (void) noexcept (true);
# 680 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 693 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 703 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 715 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 725 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) ;
# 736 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 747 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 757 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 767 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 779 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 789 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;





extern char *canonicalize_file_name (const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__))
                              ;
# 806 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
         char *__restrict __resolved) noexcept (true) ;






typedef int (*__compar_fn_t) (const void *, const void *);


typedef __compar_fn_t comparison_fn_t;



typedef int (*__compar_d_fn_t) (const void *, const void *, void *);




extern void *bsearch (const void *__key, const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5))) ;


# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
  __compar_fn_t __compar)
{
  size_t __l, __u, __idx;
  const void *__p;
  int __comparison;

  __l = 0;
  __u = __nmemb;
  while (__l < __u)
    {
      __idx = (__l + __u) / 2;
      __p = (const void *) (((const char *) __base) + (__idx * __size));
      __comparison = (*__compar) (__key, __p);
      if (__comparison < 0)
 __u = __idx;
      else if (__comparison > 0)
 __l = __idx + 1;
      else
 {




   return (void *) __p;



 }
    }

  return __null;
}
# 832 "/usr/include/stdlib.h" 2 3 4




extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
       __compar_d_fn_t __compar, void *__arg)
  __attribute__ ((__nonnull__ (1, 4)));




extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ;
extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ;


__extension__ extern long long int llabs (long long int __x)
     noexcept (true) __attribute__ ((__const__)) ;






extern div_t div (int __numer, int __denom)
     noexcept (true) __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
     noexcept (true) __attribute__ ((__const__)) ;


__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     noexcept (true) __attribute__ ((__const__)) ;
# 878 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;




extern char *gcvt (double __value, int __ndigit, char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (3))) ;




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (3))) ;




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));





extern int mblen (const char *__s, size_t __n) noexcept (true);


extern int mbtowc (wchar_t *__restrict __pwc,
     const char *__restrict __s, size_t __n) noexcept (true);


extern int wctomb (char *__s, wchar_t __wchar) noexcept (true);



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   const char *__restrict __s, size_t __n) noexcept (true)
                                      ;

extern size_t wcstombs (char *__restrict __s,
   const wchar_t *__restrict __pwcs, size_t __n)
     noexcept (true)

                                    ;






extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 965 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *const *__restrict __tokens,
        char **__restrict __valuep)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ;







extern int posix_openpt (int __oflag) ;







extern int grantpt (int __fd) noexcept (true);



extern int unlockpt (int __fd) noexcept (true);




extern char *ptsname (int __fd) noexcept (true) ;






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1021 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
 atof (const char *__nptr) noexcept (true)
{
  return strtod (__nptr, (char **) __null);
}
# 1022 "/usr/include/stdlib.h" 2 3 4
# 1033 "/usr/include/stdlib.h" 3 4
}
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 2 3

#pragma GCC diagnostic pop

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_abs.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_abs.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wlong-long"
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_abs.h" 3
}
}

#pragma GCC diagnostic pop
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 2 3
# 131 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::div_t;
  using ::ldiv_t;

  using ::abort;

  using ::aligned_alloc;

  using ::atexit;


  using ::at_quick_exit;


  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;


  using ::quick_exit;


  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;



  inline ldiv_t
  div(long __i, long __j) noexcept { return ldiv(__i, __j); }




}
# 205 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  using ::lldiv_t;





  using ::_Exit;



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
  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;
#pragma GCC diagnostic pop
# 240 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 284 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdlib" 3
}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/string_conversions.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdio" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 34 "/usr/include/stdio.h" 2 3 4


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/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
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 36 "/usr/include/bits/types/struct_FILE.h" 2 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;
# 117 "/usr/include/bits/types/struct_FILE.h" 3 4
  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;
# 84 "/usr/include/stdio.h" 3 4
typedef __fpos_t fpos_t;




typedef __fpos64_t fpos64_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/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) noexcept (true);

extern int rename (const char *__old, const char *__new) noexcept (true);



extern int renameat (int __oldfd, const char *__old, int __newfd,
       const char *__new) noexcept (true);
# 164 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
        const char *__new, unsigned int __flags) noexcept (true);






extern int fclose (FILE *__stream);
# 182 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void)
  __attribute__ ((__malloc__)) ;
# 194 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void)
   __attribute__ ((__malloc__)) ;



extern char *tmpnam (char[20]) noexcept (true) ;




extern char *tmpnam_r (char __s[20]) noexcept (true) ;
# 216 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
   noexcept (true) __attribute__ ((__malloc__)) ;






extern int fflush (FILE *__stream);
# 233 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 243 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 252 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
      const char *__restrict __modes)
  __attribute__ ((__malloc__)) ;




extern FILE *freopen (const char *__restrict __filename,
        const char *__restrict __modes,
        FILE *__restrict __stream) ;
# 277 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
        const char *__restrict __modes)
  __attribute__ ((__malloc__)) ;
extern FILE *freopen64 (const char *__restrict __filename,
   const char *__restrict __modes,
   FILE *__restrict __stream) ;




extern FILE *fdopen (int __fd, const char *__modes) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern FILE *fopencookie (void *__restrict __magic_cookie,
     const char *__restrict __modes,
     cookie_io_functions_t __io_funcs) noexcept (true)
  __attribute__ ((__malloc__)) ;




extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
  noexcept (true) __attribute__ ((__malloc__)) ;




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true);



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) noexcept (true);




extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) noexcept (true);


extern void setlinebuf (FILE *__stream) noexcept (true);







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, ...) noexcept (true);





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) noexcept (true);



extern int snprintf (char *__restrict __s, size_t __maxlen,
       const char *__restrict __format, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        const char *__restrict __format, __gnuc_va_list __arg)
     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0)));





extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
        __gnuc_va_list __arg)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
         const char *__restrict __fmt, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
       const char *__restrict __fmt, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ;




extern int vdprintf (int __fd, const char *__restrict __fmt,
       __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));







extern int fscanf (FILE *__restrict __stream,
     const char *__restrict __format, ...) ;




extern int scanf (const char *__restrict __format, ...) ;

extern int sscanf (const char *__restrict __s,
     const char *__restrict __format, ...) noexcept (true);
# 428 "/usr/include/stdio.h" 3 4
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") ;


extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") ;

extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc99_sscanf");
# 453 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) ;





extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) ;


extern int vsscanf (const char *__restrict __s,
      const char *__restrict __format, __gnuc_va_list __arg)
     noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")

     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_vsscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0)));
# 507 "/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);
# 532 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 543 "/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);
# 559 "/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)
                                                         ;
# 609 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream)
                                                  ;
# 626 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
                           size_t *__restrict __n, int __delimiter,
                           FILE *__restrict __stream) ;







extern __ssize_t getline (char **__restrict __lineptr,
                          size_t *__restrict __n,
                          FILE *__restrict __stream) ;







extern int fputs (const char *__restrict __s, FILE *__restrict __stream);





extern int puts (const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream) ;




extern size_t fwrite (const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);
# 685 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
      FILE *__restrict __stream);
# 696 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);







extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream) ;




extern void rewind (FILE *__stream);
# 730 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream) ;
# 754 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 773 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);



extern void clearerr (FILE *__stream) noexcept (true);

extern int feof (FILE *__stream) noexcept (true) ;

extern int ferror (FILE *__stream) noexcept (true) ;



extern void clearerr_unlocked (FILE *__stream) noexcept (true);
extern int feof_unlocked (FILE *__stream) noexcept (true) ;
extern int ferror_unlocked (FILE *__stream) noexcept (true) ;







extern void perror (const char *__s);




extern int fileno (FILE *__stream) noexcept (true) ;




extern int fileno_unlocked (FILE *__stream) noexcept (true) ;
# 817 "/usr/include/stdio.h" 3 4
extern int pclose (FILE *__stream);





extern FILE *popen (const char *__command, const char *__modes)
  __attribute__ ((__malloc__)) ;






extern char *ctermid (char *__s) noexcept (true)
                                     ;





extern char *cuserid (char *__s)
                                     ;




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      const char *__restrict __format, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       const char *__restrict __format,
       __gnuc_va_list __args)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) noexcept (true);



extern int ftrylockfile (FILE *__stream) noexcept (true) ;


extern void funlockfile (FILE *__stream) noexcept (true);
# 879 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 896 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 38 "/usr/include/bits/stdio.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}



extern __inline __attribute__ ((__gnu_inline__)) int
getchar (void)
{
  return getc (stdin);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fgetc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}





extern __inline __attribute__ ((__gnu_inline__)) int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline __attribute__ ((__gnu_inline__)) int
getchar_unlocked (void)
{
  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline __attribute__ ((__gnu_inline__)) int
putchar (int __c)
{
  return putc (__c, stdout);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline __attribute__ ((__gnu_inline__)) int
putchar_unlocked (int __c)
{
  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





extern __inline __attribute__ ((__gnu_inline__)) int
 feof_unlocked (FILE *__stream) noexcept (true)
{
  return (((__stream)->_flags & 0x0010) != 0);
}


extern __inline __attribute__ ((__gnu_inline__)) int
 ferror_unlocked (FILE *__stream) noexcept (true)
{
  return (((__stream)->_flags & 0x0020) != 0);
}
# 897 "/usr/include/stdio.h" 2 3 4






}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdio" 2 3
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 159 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdio" 3
namespace __gnu_cxx
{
# 177 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/string_conversions.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cerrno" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cerrno" 3
# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/bits/errno.h" 1 3 4
# 26 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4




# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 6 "/usr/include/asm-generic/errno.h" 2 3 4
# 2 "/usr/include/asm/errno.h" 2 3 4
# 2 "/usr/include/linux/errno.h" 2 3 4
# 27 "/usr/include/bits/errno.h" 2 3 4
# 29 "/usr/include/errno.h" 2 3 4





extern "C" {


extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__));







extern char *program_invocation_name;
extern char *program_invocation_short_name;

# 1 "/usr/include/bits/types/error_t.h" 1 3 4
# 22 "/usr/include/bits/types/error_t.h" 3 4
typedef int error_t;
# 49 "/usr/include/errno.h" 2 3 4



}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cerrno" 2 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }


}
# 4445 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/charconv.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/charconv.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __detail
{


  template<typename _Tp>
    constexpr bool __integer_to_chars_is_unsigned
      = ! __gnu_cxx::__int_traits<_Tp>::__is_signed;



  template<typename _Tp>
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base = 10) noexcept
    {

      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");


      unsigned __n = 1;
      const unsigned __b2 = __base * __base;
      const unsigned __b3 = __b2 * __base;
      const unsigned long __b4 = __b3 * __base;
      for (;;)
 {
   if (__value < (unsigned)__base) return __n;
   if (__value < __b2) return __n + 1;
   if (__value < __b3) return __n + 2;
   if (__value < __b4) return __n + 3;
   __value /= __b4;
   __n += 4;
 }
    }




  template<typename _Tp>
                         void
    __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
    {

      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");


      constexpr char __digits[201] =
 "0001020304050607080910111213141516171819"
 "2021222324252627282930313233343536373839"
 "4041424344454647484950515253545556575859"
 "6061626364656667686970717273747576777879"
 "8081828384858687888990919293949596979899";
      unsigned __pos = __len - 1;
      while (__val >= 100)
 {
   auto const __num = (__val % 100) * 2;
   __val /= 100;
   __first[__pos] = __digits[__num + 1];
   __first[__pos - 1] = __digits[__num];
   __pos -= 2;
 }
      if (__val >= 10)
 {
   auto const __num = __val * 2;
   __first[1] = __digits[__num + 1];
   __first[0] = __digits[__num];
 }
      else
 __first[0] = '0' + __val;
    }

}

}
# 4446 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 4488 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  inline double
  stod(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }



  inline float
  stof(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
# 4516 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  inline long double
  stold(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
# 4528 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  [[__nodiscard__]]
  inline string
  to_string(int __val)

  noexcept

  {
    const bool __neg = __val < 0;
    const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned __val)

  noexcept

  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(long __val)



  {
    const bool __neg = __val < 0;
    const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned long __val)



  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(long long __val)
  {
    const bool __neg = __val < 0;
    const unsigned long long __uval
      = __neg ? (unsigned long long)~__val + 1ull : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned long long __val)
  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }
# 4687 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
#pragma GCC diagnostic push



  [[__nodiscard__]]
  inline string
  to_string(float __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  [[__nodiscard__]]
  inline string
  to_string(double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  [[__nodiscard__]]
  inline string
  to_string(long double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%Lf", __val);
  }
#pragma GCC diagnostic pop



  inline int
  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
     __idx, __base); }

  inline long
  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
        __idx, __base); }

  inline unsigned long
  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
        __idx, __base); }

  inline long long
  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
        __idx, __base); }

  inline unsigned long long
  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
        __idx, __base); }


  inline float
  stof(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }

  inline double
  stod(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }

  inline long double
  stold(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  constexpr
  inline void
  __to_wstring_numeric(const char* __s, int __len, wchar_t* __wout)
  {


    if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'
      && wchar_t('.') == L'.' && wchar_t('e') == L'e')
      {
 for (int __i = 0; __i < __len; ++__i)
   __wout[__i] = (wchar_t) __s[__i];
      }
    else
      {
 wchar_t __wc[256];
 for (int __i = '0'; __i <= '9'; ++__i)
   __wc[__i] = L'0' + __i;
 __wc['.'] = L'.';
 __wc['+'] = L'+';
 __wc['-'] = L'-';
 __wc['a'] = L'a';
 __wc['b'] = L'b';
 __wc['c'] = L'c';
 __wc['d'] = L'd';
 __wc['e'] = L'e';
 __wc['f'] = L'f';
 __wc['i'] = L'i';
 __wc['n'] = L'n';
 __wc['p'] = L'p';
 __wc['x'] = L'x';
 __wc['A'] = L'A';
 __wc['B'] = L'B';
 __wc['C'] = L'C';
 __wc['D'] = L'D';
 __wc['E'] = L'E';
 __wc['F'] = L'F';
 __wc['I'] = L'I';
 __wc['N'] = L'N';
 __wc['P'] = L'P';
 __wc['X'] = L'X';

 for (int __i = 0; __i < __len; ++__i)
   __wout[__i] = __wc[(int)__s[__i]];
      }
  }


  constexpr

  inline wstring

  __to_wstring_numeric(string_view __s)



  {
    if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'
      && wchar_t('.') == L'.' && wchar_t('e') == L'e')
      return wstring(__s.data(), __s.data() + __s.size());
    else
      {
 wstring __ws;
 auto __f = __s.data();
 __ws.__resize_and_overwrite(__s.size(),
        [__f] (wchar_t* __to, int __n) {
          std::__to_wstring_numeric(__f, __n, __to);
          return __n;
        });
 return __ws;
      }
  }
#pragma GCC diagnostic pop

  [[__nodiscard__]]
  inline wstring
  to_wstring(int __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned long long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }


  [[__nodiscard__]]
  inline wstring
  to_wstring(float __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(double __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long double __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }



}

}







namespace std __attribute__ ((__visibility__ ("default")))
{





  template<typename _CharT, typename _Alloc,
    typename _StrT = basic_string<_CharT, char_traits<_CharT>, _Alloc>>
    struct __str_hash_base
    : public __hash_base<size_t, _StrT>
    {
      [[__nodiscard__]]
      size_t
      operator()(const _StrT& __s) const noexcept
      { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); }
    };



  template<typename _Alloc>
    struct hash<basic_string<char, char_traits<char>, _Alloc>>
    : public __str_hash_base<char, _Alloc>
    { };


  template<typename _Alloc>
    struct hash<basic_string<wchar_t, char_traits<wchar_t>, _Alloc>>
    : public __str_hash_base<wchar_t, _Alloc>
    { };

  template<typename _Alloc>
    struct __is_fast_hash<hash<basic_string<wchar_t, char_traits<wchar_t>,
         _Alloc>>>
    : std::false_type
    { };




  template<typename _Alloc>
    struct hash<basic_string<char8_t, char_traits<char8_t>, _Alloc>>
    : public __str_hash_base<char8_t, _Alloc>
    { };



  template<typename _Alloc>
    struct hash<basic_string<char16_t, char_traits<char16_t>, _Alloc>>
    : public __str_hash_base<char16_t, _Alloc>
    { };


  template<typename _Alloc>
    struct hash<basic_string<char32_t, char_traits<char32_t>, _Alloc>>
    : public __str_hash_base<char32_t, _Alloc>
    { };



  template<> struct __is_fast_hash<hash<string>> : std::false_type { };
  template<> struct __is_fast_hash<hash<wstring>> : std::false_type { };
  template<> struct __is_fast_hash<hash<u16string>> : std::false_type { };
  template<> struct __is_fast_hash<hash<u32string>> : std::false_type { };

  template<> struct __is_fast_hash<hash<u8string>> : std::false_type { };
# 4973 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.h" 3
  inline namespace literals
  {
  inline namespace string_literals
  {
#pragma GCC diagnostic push








    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char>
    operator""s(const char* __str, size_t __len)
    { return basic_string<char>{__str, __len}; }

    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<wchar_t>
    operator""s(const wchar_t* __str, size_t __len)
    { return basic_string<wchar_t>{__str, __len}; }


    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char8_t>
    operator""s(const char8_t* __str, size_t __len)
    { return basic_string<char8_t>{__str, __len}; }


    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char16_t>
    operator""s(const char16_t* __str, size_t __len)
    { return basic_string<char16_t>{__str, __len}; }

    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char32_t>
    operator""s(const char32_t* __str, size_t __len)
    { return basic_string<char32_t>{__str, __len}; }


#pragma GCC diagnostic pop
  }
  }



  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Traits, typename _Alloc>
      struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
      : __and_<
 is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
 is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
 >::type
      { };
  }



}
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"



namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    swap(basic_string& __s) noexcept
    {
      if (this == std::__addressof(__s))
 return;

      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());

      if (_M_is_local())
 if (__s._M_is_local())
   {
     if (length() && __s.length())
       {
  _CharT __tmp_data[_S_local_capacity + 1];
  traits_type::copy(__tmp_data, __s._M_local_buf,
      __s.length() + 1);
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      length() + 1);
  traits_type::copy(_M_local_buf, __tmp_data,
      __s.length() + 1);
       }
     else if (__s.length())
       {
  _M_init_local_buf();
  traits_type::copy(_M_local_buf, __s._M_local_buf,
      __s.length() + 1);
  _M_length(__s.length());
  __s._M_set_length(0);
  return;
       }
     else if (length())
       {
  __s._M_init_local_buf();
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      length() + 1);
  __s._M_length(length());
  _M_set_length(0);
  return;
       }
   }
 else
   {
     const size_type __tmp_capacity = __s._M_allocated_capacity;
     __s._M_init_local_buf();
     traits_type::copy(__s._M_local_buf, _M_local_buf,
         length() + 1);
     _M_data(__s._M_data());
     __s._M_data(__s._M_local_buf);
     _M_capacity(__tmp_capacity);
   }
      else
 {
   const size_type __tmp_capacity = _M_allocated_capacity;
   if (__s._M_is_local())
     {
       _M_init_local_buf();
       traits_type::copy(_M_local_buf, __s._M_local_buf,
    __s.length() + 1);
       __s._M_data(_M_data());
       _M_data(_M_local_buf);
     }
   else
     {
       pointer __tmp_ptr = _M_data();
       _M_data(__s._M_data());
       __s._M_data(__tmp_ptr);
       _M_capacity(__s._M_allocated_capacity);
     }
   __s._M_capacity(__tmp_capacity);
 }

      const size_type __tmp_length = length();
      _M_length(__s.length());
      __s._M_length(__tmp_length);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::pointer
    basic_string<_CharT, _Traits, _Alloc>::
    _M_create(size_type& __capacity, size_type __old_capacity)
    {


      if (__capacity > max_size())
 std::__throw_length_error(("basic_string::_M_create"));




      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 {
   __capacity = 2 * __old_capacity;

   if (__capacity > max_size())
     __capacity = max_size();
 }



      return _S_allocate(_M_get_allocator(), __capacity + 1);
    }





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      constexpr
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::input_iterator_tag)
      {
 size_type __len = 0;
 size_type __capacity = size_type(_S_local_capacity);

 _M_init_local_buf();

 while (__beg != __end && __len < __capacity)
   {
     _M_local_buf[__len++] = *__beg;
     ++__beg;
   }

 struct _Guard
 {
   constexpr
   explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

   constexpr
   ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

   basic_string* _M_guarded;
 } __guard(this);

 while (__beg != __end)
   {
     if (__len == __capacity)
       {

  __capacity = __len + 1;
  pointer __another = _M_create(__capacity, __len);
  this->_S_copy(__another, _M_data(), __len);
  _M_dispose();
  _M_data(__another);
  _M_capacity(__capacity);
       }
     traits_type::assign(_M_data()[__len++],
    static_cast<_CharT>(*__beg));
     ++__beg;
   }

 __guard._M_guarded = 0;

 _M_set_length(__len);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      constexpr
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::forward_iterator_tag)
      {
 size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

 if (__dnew > size_type(_S_local_capacity))
   {
     _M_data(_M_create(__dnew, size_type(0)));
     _M_capacity(__dnew);
   }
 else
   _M_init_local_buf();


 struct _Guard
 {
   constexpr
   explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

   constexpr
   ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

   basic_string* _M_guarded;
 } __guard(this);

 this->_S_copy_chars(_M_data(), __beg, __end);

 __guard._M_guarded = 0;

 _M_set_length(__dnew);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_construct(size_type __n, _CharT __c)
    {
      if (__n > size_type(_S_local_capacity))
 {
   _M_data(_M_create(__n, size_type(0)));
   _M_capacity(__n);
 }
      else
 _M_init_local_buf();

      if (__n)
 this->_S_assign(_M_data(), __n, __c);

      _M_set_length(__n);
    }



  template<typename _CharT, typename _Traits, typename _Alloc>
    template<bool _Terminated>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_construct(const _CharT* __str, size_type __n)
    {
      if (__n > size_type(_S_local_capacity))
 {
   _M_data(_M_create(__n, size_type(0)));
   _M_capacity(__n);
 }
      else
 _M_init_local_buf();

      if (__n || _Terminated)
 this->_S_copy(_M_data(), __str, __n + _Terminated);

      _M_length(__n);
      if (!_Terminated)
 traits_type::assign(_M_data()[__n], _CharT());
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_assign(const basic_string& __str)
    {
      if (this != std::__addressof(__str))
 {
   const size_type __rsize = __str.length();
   const size_type __capacity = capacity();

   if (__rsize > __capacity)
     {
       size_type __new_capacity = __rsize;
       pointer __tmp = _M_create(__new_capacity, __capacity);
       _M_dispose();
       _M_data(__tmp);
       _M_capacity(__new_capacity);
     }

   if (__rsize)
     this->_S_copy(_M_data(), __str._M_data(), __rsize);

   _M_set_length(__rsize);
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve(size_type __res)
    {
      const size_type __capacity = capacity();




      if (__res <= __capacity)
 return;

      pointer __tmp = _M_create(__res, __capacity);
      this->_S_copy(__tmp, _M_data(), length() + 1);
      _M_dispose();
      _M_data(__tmp);
      _M_capacity(__res);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
       size_type __len2)
    {
      const size_type __how_much = length() - __pos - __len1;

      size_type __new_capacity = length() + __len2 - __len1;
      pointer __r = _M_create(__new_capacity, capacity());

      if (__pos)
 this->_S_copy(__r, _M_data(), __pos);
      if (__s && __len2)
 this->_S_copy(__r + __pos, __s, __len2);
      if (__how_much)
 this->_S_copy(__r + __pos + __len2,
        _M_data() + __pos + __len1, __how_much);

      _M_dispose();
      _M_data(__r);
      _M_capacity(__new_capacity);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_erase(size_type __pos, size_type __n)
    {
      const size_type __how_much = length() - __pos - __n;

      if (__how_much && __n)
 this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);

      _M_set_length(length() - __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve()
    {
      if (_M_is_local())
 return;

      const size_type __length = length();
      const size_type __capacity = _M_allocated_capacity;

      if (__length <= size_type(_S_local_capacity))
 {
   _M_init_local_buf();
   this->_S_copy(_M_local_buf, _M_data(), __length + 1);
   _M_destroy(__capacity);
   _M_data(_M_local_data());
 }

      else if (__length < __capacity)
 try
   {
     pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1);
     this->_S_copy(__tmp, _M_data(), __length + 1);
     _M_dispose();
     _M_data(__tmp);
     _M_capacity(__length);
   }
 catch (const __cxxabiv1::__forced_unwind&)
   { throw; }
 catch (...)
   { }

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    resize(size_type __n, _CharT __c)
    {
      const size_type __size = this->size();
      if (__size < __n)
 this->append(__n - __size, __c);
      else if (__n < __size)
 this->_M_set_length(__n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_append(const _CharT* __s, size_type __n)
    {
      const size_type __len = __n + this->size();

      if (__len <= this->capacity())
 {
   if (__n)
     this->_S_copy(this->_M_data() + this->size(), __s, __n);
 }
      else
 this->_M_mutate(this->size(), size_type(0), __s, __n);

      this->_M_set_length(__len);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
     _InputIterator __k1, _InputIterator __k2,
     std::__false_type)
      {


 const basic_string __s(__k1, __k2, this->get_allocator());
 const size_type __n1 = __i2 - __i1;
 return _M_replace(__i1 - begin(), __n1, __s._M_data(),
     __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     _CharT __c)
    {
      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __n2 - __n1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos1;

   const size_type __how_much = __old_size - __pos1 - __n1;
   if (__how_much && __n1 != __n2)
     this->_S_move(__p + __n2, __p + __n1, __how_much);
 }
      else
 this->_M_mutate(__pos1, __n1, 0, __n2);

      if (__n2)
 this->_S_assign(this->_M_data() + __pos1, __n2, __c);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    __attribute__((__noinline__, __noclone__, __cold__)) void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
      const size_type __len2, const size_type __how_much)
    {

      if (__len2 && __len2 <= __len1)
 this->_S_move(__p, __s, __len2);
      if (__how_much && __len1 != __len2)
 this->_S_move(__p + __len2, __p + __len1, __how_much);
      if (__len2 > __len1)
 {
   if (__s + __len2 <= __p + __len1)
     this->_S_move(__p, __s, __len2);
   else if (__s >= __p + __len1)
     {


       const size_type __poff = (__s - __p) + (__len2 - __len1);
       this->_S_copy(__p, __p + __poff, __len2);
     }
   else
     {
       const size_type __nleft = (__p + __len1) - __s;
       this->_S_move(__p, __s, __nleft);
       this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft);
     }
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
        const size_type __len2)
    {
      _M_check_length(__len1, __len2, "basic_string::_M_replace");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos;

   const size_type __how_much = __old_size - __pos - __len1;

   if (std::is_constant_evaluated())
     {
       auto __newp = _S_allocate(_M_get_allocator(), __new_size);
       _S_copy(__newp, this->_M_data(), __pos);
       _S_copy(__newp + __pos, __s, __len2);
       _S_copy(__newp + __pos + __len2, __p + __len1, __how_much);
       _S_copy(this->_M_data(), __newp, __new_size);
       this->_M_get_allocator().deallocate(__newp, __new_size);
     }
   else

   if (__builtin_expect(_M_disjunct(__s), true))
     {
       if (__how_much && __len1 != __len2)
  this->_S_move(__p + __len2, __p + __len1, __how_much);
       if (__len2)
  this->_S_copy(__p, __s, __len2);
     }
   else
     _M_replace_cold(__p, __len1, __s, __len2, __how_much);
 }
      else
 this->_M_mutate(__pos, __len1, __s, __len2);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
                                             ;
      if (__n)
 _S_copy(__s, _M_data() + __pos, __n);

      return __n;
    }
# 611 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
  template<typename _Operation>
    constexpr void
    basic_string<_CharT, _Traits, _Alloc>::



    __resize_and_overwrite(const size_type __n, _Operation __op)

    {
      reserve(__n);
      _CharT* const __p = _M_data();

      if (std::__is_constant_evaluated() && __n > size())
 traits_type::assign(__p + size(), __n - size(), _CharT());

      struct _Terminator {
 constexpr ~_Terminator() { _M_this->_M_set_length(_M_r); }
 basic_string* _M_this;
 size_type _M_r;
      };
      _Terminator __term{this, 0};
      auto __r = std::move(__op)(__p + 0, __n + 0);

      static_assert(ranges::__detail::__is_integer_like<decltype(__r)>);




                                                              ;
      __term._M_r = size_type(__r);
      if (__term._M_r > __n)
 __builtin_unreachable();
    }
# 654 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      const size_type __size = this->size();

      if (__n == 0)
 return __pos <= __size ? __pos : npos;
      if (__pos >= __size)
 return npos;

      const _CharT __elem0 = __s[0];
      const _CharT* const __data = data();
      const _CharT* __first = __data + __pos;
      const _CharT* const __last = __data + __size;
      size_type __len = __size - __pos;

      while (__len >= __n)
 {

   __first = traits_type::find(__first, __len - __n + 1, __elem0);
   if (!__first)
     return npos;



   if (traits_type::compare(__first, __s, __n) == 0)
     return __first - __data;
   __len = __last - ++__first;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const size_type __n = __size - __pos;
   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
   if (__p)
     __ret = __p - __data;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__size - __n), __pos);
   const _CharT* __data = _M_data();
   do
     {
       if (traits_type::compare(__data + __pos, __s, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      for (; __n && __pos < this->size(); ++__pos)
 {
   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(_M_data()[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }




  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;
      typedef ctype<_CharT> __ctype_type;
      typedef typename __ctype_type::ctype_base __ctype_base;

      __size_type __extracted = 0;
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(__ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }
       __str.append(__buf, __len);

       if (__extracted < __n && _Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {
       __str.erase();
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __in.rdbuf()->sbumpc();
  }
       else
  __err |= __ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }
# 1016 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 3
  extern template void
    basic_string<char>::_M_replace_cold(char *, size_type, const char*,
     const size_type, const size_type);


  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);
# 1042 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_string.tcc" 3
  extern template void
    basic_string<wchar_t>::_M_replace_cold(wchar_t*, size_type, const wchar_t*,
        const size_type, const size_type);


  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);




}

#pragma GCC diagnostic pop
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstddef" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstddef" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_wchar_t.h" 1 3
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_nullptr_t.h" 1 3
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_offsetof.h" 1 3
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstddef" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstddef" 2 3

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

extern "C++"
{

namespace std
{

  using ::max_align_t;
}



namespace std
{


  enum class byte : unsigned char {};

  template<typename _IntegerType> struct __byte_operand { };
  template<> struct __byte_operand<bool> { using __type = byte; };
  template<> struct __byte_operand<char> { using __type = byte; };
  template<> struct __byte_operand<signed char> { using __type = byte; };
  template<> struct __byte_operand<unsigned char> { using __type = byte; };
  template<> struct __byte_operand<wchar_t> { using __type = byte; };

  template<> struct __byte_operand<char8_t> { using __type = byte; };

  template<> struct __byte_operand<char16_t> { using __type = byte; };
  template<> struct __byte_operand<char32_t> { using __type = byte; };
  template<> struct __byte_operand<short> { using __type = byte; };
  template<> struct __byte_operand<unsigned short> { using __type = byte; };
  template<> struct __byte_operand<int> { using __type = byte; };
  template<> struct __byte_operand<unsigned int> { using __type = byte; };
  template<> struct __byte_operand<long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long> { using __type = byte; };
  template<> struct __byte_operand<long long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long long> { using __type = byte; };
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstddef" 3
  template<typename _IntegerType>
    struct __byte_operand<const _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<volatile _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<const volatile _IntegerType>
    : __byte_operand<_IntegerType> { };

  template<typename _IntegerType>
    using __byte_op_t = typename __byte_operand<_IntegerType>::__type;

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>
    operator<<(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b << __shift); }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>
    operator>>(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b >> __shift); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator|(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator&(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator^(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator~(byte __b) noexcept
  { return (byte)(unsigned char)~(unsigned)__b; }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>&
    operator<<=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b << __shift; }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>&
    operator>>=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b >> __shift; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator|=(byte& __l, byte __r) noexcept
  { return __l = __l | __r; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator&=(byte& __l, byte __r) noexcept
  { return __l = __l & __r; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator^=(byte& __l, byte __r) noexcept
  { return __l = __l ^ __r; }

  template<typename _IntegerType>
    [[nodiscard,__gnu__::__always_inline__]]
    constexpr _IntegerType
    to_integer(__byte_op_t<_IntegerType> __b) noexcept
    { return _IntegerType(__b); }


}

}

#pragma GCC diagnostic pop
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  struct __erased_type { };




  template<typename _Alloc, typename _Tp>
    using __is_erased_or_convertible
      = __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;


  struct allocator_arg_t { explicit allocator_arg_t() = default; };

  inline constexpr allocator_arg_t allocator_arg =
    allocator_arg_t();

  template<typename _Tp, typename _Alloc, typename = __void_t<>>
    struct __uses_allocator_helper
    : false_type { };

  template<typename _Tp, typename _Alloc>
    struct __uses_allocator_helper<_Tp, _Alloc,
       __void_t<typename _Tp::allocator_type>>
    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
    { };


  template<typename _Tp, typename _Alloc>
    struct uses_allocator
    : __uses_allocator_helper<_Tp, _Alloc>::type
    { };

  struct __uses_alloc_base { };

  struct __uses_alloc0 : __uses_alloc_base
  {
    struct _Sink { void constexpr operator=(const void*) { } } _M_a;
  };

  template<typename _Alloc>
    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };

  template<typename _Alloc>
    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };

  template<bool, typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc;

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
    : __conditional_t<
        is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
        __uses_alloc1<_Alloc>,
        __uses_alloc2<_Alloc>>
    {


      static_assert(__or_<
   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
   "construction with an allocator must be possible"
   " if uses_allocator is true");
    };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
    : __uses_alloc0 { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    using __uses_alloc_t =
      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;

  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr
    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
    __use_alloc(const _Alloc& __a)
    {
      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
      __ret._M_a = std::__addressof(__a);
      return __ret;
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void
    __use_alloc(const _Alloc&&) = delete;


  template <typename _Tp, typename _Alloc>
    inline constexpr bool uses_allocator_v =
      uses_allocator<_Tp, _Alloc>::value;



  template<typename _Alloc, typename... _Ts>
    concept __allocator_for = (uses_allocator_v<_Ts, _Alloc> && ...);


  template<template<typename...> class _Predicate,
    typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_predicate
    : __conditional_t<uses_allocator<_Tp, _Alloc>::value,
      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
     _Predicate<_Tp, _Args..., _Alloc>>,
      _Predicate<_Tp, _Args...>> { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
    { };


  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool __is_uses_allocator_constructible_v =
      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_nothrow_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_nothrow_constructible,
        _Tp, _Alloc, _Args...>
    { };



  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool
    __is_nothrow_uses_allocator_constructible_v =
      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc0, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    {
      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
          std::forward<_Args>(__args)...);
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
        _Args&&... __args)
    {
      std::__uses_allocator_construct_impl(
   std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
   std::forward<_Args>(__args)...);
    }



}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_util.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_util.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{


  namespace __detail
  {
    template<typename _Range>
      concept __simple_view = view<_Range> && range<const _Range>
 && same_as<iterator_t<_Range>, iterator_t<const _Range>>
 && same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;



    template<typename _It>
      concept __has_arrow = input_iterator<_It>
 && (is_pointer_v<_It>
       || requires(const _It __it) { __it.operator->(); });

    using std::__detail::__different_from;
  }


  template<typename _Derived>
    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface
    {
    private:
      constexpr _Derived& _M_derived() noexcept
      {
 static_assert(derived_from<_Derived, view_interface<_Derived>>);
 static_assert(view<_Derived>);
 return static_cast<_Derived&>(*this);
      }

      constexpr const _Derived& _M_derived() const noexcept
      {
 static_assert(derived_from<_Derived, view_interface<_Derived>>);
 static_assert(view<_Derived>);
 return static_cast<const _Derived&>(*this);
      }

      static constexpr bool
      _S_bool(bool) noexcept;

      template<typename _Tp>
 static constexpr bool
 _S_empty(_Tp& __t)
 noexcept(noexcept(_S_bool(ranges::begin(__t) == ranges::end(__t))))
 { return ranges::begin(__t) == ranges::end(__t); }

      template<typename _Tp>
 static constexpr auto
 _S_size(_Tp& __t)
 noexcept(noexcept(ranges::end(__t) - ranges::begin(__t)))
 { return ranges::end(__t) - ranges::begin(__t); }

    public:
      constexpr bool
      empty()
      noexcept(noexcept(_S_empty(_M_derived())))
      requires forward_range<_Derived> && (!sized_range<_Derived>)
      { return _S_empty(_M_derived()); }

      constexpr bool
      empty()
      noexcept(noexcept(ranges::size(_M_derived()) == 0))
      requires sized_range<_Derived>
      { return ranges::size(_M_derived()) == 0; }

      constexpr bool
      empty() const
      noexcept(noexcept(_S_empty(_M_derived())))
      requires forward_range<const _Derived> && (!sized_range<const _Derived>)
      { return _S_empty(_M_derived()); }

      constexpr bool
      empty() const
      noexcept(noexcept(ranges::size(_M_derived()) == 0))
      requires sized_range<const _Derived>
      { return ranges::size(_M_derived()) == 0; }

      constexpr explicit
      operator bool() noexcept(noexcept(ranges::empty(_M_derived())))
      requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr explicit
      operator bool() const noexcept(noexcept(ranges::empty(_M_derived())))
      requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr auto
      data() noexcept(noexcept(ranges::begin(_M_derived())))
      requires contiguous_iterator<iterator_t<_Derived>>
      { return std::to_address(ranges::begin(_M_derived())); }

      constexpr auto
      data() const noexcept(noexcept(ranges::begin(_M_derived())))
      requires range<const _Derived>
 && contiguous_iterator<iterator_t<const _Derived>>
      { return std::to_address(ranges::begin(_M_derived())); }

      constexpr auto
      size() noexcept(noexcept(_S_size(_M_derived())))
      requires forward_range<_Derived>
 && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
      { return _S_size(_M_derived()); }

      constexpr auto
      size() const noexcept(noexcept(_S_size(_M_derived())))
      requires forward_range<const _Derived>
 && sized_sentinel_for<sentinel_t<const _Derived>,
         iterator_t<const _Derived>>
      { return _S_size(_M_derived()); }

      constexpr decltype(auto)
      front() requires forward_range<_Derived>
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      front() const requires forward_range<const _Derived>
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      back()
      requires bidirectional_range<_Derived> && common_range<_Derived>
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::prev(ranges::end(_M_derived()));
      }

      constexpr decltype(auto)
      back() const
      requires bidirectional_range<const _Derived>
 && common_range<const _Derived>
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::prev(ranges::end(_M_derived()));
      }

      template<random_access_range _Range = _Derived>
 constexpr decltype(auto)
 operator[](range_difference_t<_Range> __n)
 { return ranges::begin(_M_derived())[__n]; }

      template<random_access_range _Range = const _Derived>
 constexpr decltype(auto)
 operator[](range_difference_t<_Range> __n) const
 { return ranges::begin(_M_derived())[__n]; }
# 219 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_util.h" 3
    };

  namespace __detail
  {
    template<typename _From, typename _To>
      concept __uses_nonqualification_pointer_conversion
 = is_pointer_v<_From> && is_pointer_v<_To>
   && !convertible_to<remove_pointer_t<_From>(*)[],
        remove_pointer_t<_To>(*)[]>;

    template<typename _From, typename _To>
      concept __convertible_to_non_slicing = convertible_to<_From, _To>
 && !__uses_nonqualification_pointer_conversion<decay_t<_From>,
             decay_t<_To>>;





    template<typename _Tp>
      concept __pair_like
 = !is_reference_v<_Tp> && requires(_Tp __t)
 {
   typename tuple_size<_Tp>::type;
   requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
   typename tuple_element_t<0, remove_const_t<_Tp>>;
   typename tuple_element_t<1, remove_const_t<_Tp>>;
   { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
   { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
 };


    template<typename _Tp, typename _Up, typename _Vp>
      concept __pair_like_convertible_from
 = !range<_Tp> && !is_reference_v<_Tp> && __pair_like<_Tp>
 && constructible_from<_Tp, _Up, _Vp>
 && __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
 && convertible_to<_Vp, tuple_element_t<1, _Tp>>;

  }

  namespace views { struct _Drop; }

  enum class subrange_kind : bool { unsized, sized };


  template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
    subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
      ? subrange_kind::sized : subrange_kind::unsized>
    requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
    class subrange : public view_interface<subrange<_It, _Sent, _Kind>>
    {
    private:
      static constexpr bool _S_store_size
 = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;

      friend struct views::_Drop;

      _It _M_begin = _It();
      [[no_unique_address]] _Sent _M_end = _Sent();

      using __size_type
 = __detail::__make_unsigned_like_t<iter_difference_t<_It>>;

      template<typename _Tp, bool = _S_store_size>
 struct _Size
 {
   [[__gnu__::__always_inline__]]
   constexpr _Size(_Tp = {}) { }
 };

      template<typename _Tp>
 struct _Size<_Tp, true>
 {
   [[__gnu__::__always_inline__]]
   constexpr _Size(_Tp __s = {}) : _M_size(__s) { }

   _Tp _M_size;
 };

      [[no_unique_address]] _Size<__size_type> _M_size = {};

    public:
      subrange() requires default_initializable<_It> = default;

      constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
      noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
        && is_nothrow_constructible_v<_Sent, _Sent&>)
 requires (!_S_store_size)
      : _M_begin(std::move(__i)), _M_end(__s)
      { }

      constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
        __size_type __n)
      noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
        && is_nothrow_constructible_v<_Sent, _Sent&>)
 requires (_Kind == subrange_kind::sized)
      : _M_begin(std::move(__i)), _M_end(__s), _M_size(__n)
      { }

      template<__detail::__different_from<subrange> _Rng>
 requires borrowed_range<_Rng>
   && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r)
 noexcept(noexcept(subrange(__r, ranges::size(__r))))
 requires _S_store_size && sized_range<_Rng>
 : subrange(__r, ranges::size(__r))
 { }

      template<__detail::__different_from<subrange> _Rng>
 requires borrowed_range<_Rng>
   && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r)
 noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r))))
 requires (!_S_store_size)
 : subrange(ranges::begin(__r), ranges::end(__r))
 { }

      template<borrowed_range _Rng>
 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r, __size_type __n)
 noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r), __n)))
 requires (_Kind == subrange_kind::sized)
 : subrange{ranges::begin(__r), ranges::end(__r), __n}
 { }

      template<__detail::__different_from<subrange> _PairLike>
 requires __detail::__pair_like_convertible_from<_PairLike, const _It&,
       const _Sent&>
 constexpr
 operator _PairLike() const
 { return _PairLike(_M_begin, _M_end); }

      constexpr _It
      begin() const requires copyable<_It>
      { return _M_begin; }

      [[nodiscard]] constexpr _It
      begin() requires (!copyable<_It>)
      { return std::move(_M_begin); }

      constexpr _Sent end() const { return _M_end; }

      constexpr bool empty() const { return _M_begin == _M_end; }

      constexpr __size_type
      size() const requires (_Kind == subrange_kind::sized)
      {
 if constexpr (_S_store_size)
   return _M_size._M_size;
 else
   return __detail::__to_unsigned_like(_M_end - _M_begin);
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t<_It> __n = 1) const &
 requires forward_iterator<_It>
      {
 auto __tmp = *this;
 __tmp.advance(__n);
 return __tmp;
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t<_It> __n = 1) &&
      {
 advance(__n);
 return std::move(*this);
      }

      [[nodiscard]] constexpr subrange
      prev(iter_difference_t<_It> __n = 1) const
 requires bidirectional_iterator<_It>
      {
 auto __tmp = *this;
 __tmp.advance(-__n);
 return __tmp;
      }

      constexpr subrange&
      advance(iter_difference_t<_It> __n)
      {


 if constexpr (bidirectional_iterator<_It>)
   if (__n < 0)
     {
       ranges::advance(_M_begin, __n);
       if constexpr (_S_store_size)
  _M_size._M_size += __detail::__to_unsigned_like(-__n);
       return *this;
     }

 do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
 auto __d = __n - ranges::advance(_M_begin, __n, _M_end);
 if constexpr (_S_store_size)
   _M_size._M_size -= __detail::__to_unsigned_like(__d);
 return *this;
      }
    };

  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent) -> subrange<_It, _Sent>;

  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent,
      __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
      -> subrange<_It, _Sent, subrange_kind::sized>;

  template<borrowed_range _Rng>
    subrange(_Rng&&)
      -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
   (sized_range<_Rng>
    || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
   ? subrange_kind::sized : subrange_kind::unsized>;

  template<borrowed_range _Rng>
    subrange(_Rng&&,
      __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
      -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;




  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
    requires ((_Num == 0 && copyable<_It>) || _Num == 1)
    constexpr auto
    get(const subrange<_It, _Sent, _Kind>& __r)
    {
      if constexpr (_Num == 0)
 return __r.begin();
      else
 return __r.end();
    }

  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
    requires (_Num < 2)
    constexpr auto
    get(subrange<_It, _Sent, _Kind>&& __r)
    {
      if constexpr (_Num == 0)
 return __r.begin();
      else
 return __r.end();
    }

  template<typename _It, typename _Sent, subrange_kind _Kind>
    inline constexpr bool
      enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;

  template<range _Range>
    using borrowed_subrange_t = __conditional_t<borrowed_range<_Range>,
      subrange<iterator_t<_Range>>,
      dangling>;


  template<typename _Iter, typename _Sent, subrange_kind _Kind>
    inline constexpr bool __detail::__is_subrange<subrange<_Iter, _Sent, _Kind>> = true;
}
# 495 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_util.h" 3
namespace ranges
{
  struct __find_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp >
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>, const _Tp*>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Proj __proj = {}) const
      {
 if constexpr (is_same_v<_Proj, identity>)
   if constexpr(__can_use_memchr_for_find<iter_value_t<_Iter>, _Tp>)
     if constexpr (sized_sentinel_for<_Sent, _Iter>)
       if constexpr (contiguous_iterator<_Iter>)
  if (!is_constant_evaluated())
    {
      using _Vt = iter_value_t<_Iter>;
      auto __n = __last - __first;
      if (static_cast<_Vt>(__value) == __value) [[likely]]
        if (__n > 0)
   {
     const size_t __nu = static_cast<size_t>(__n);
     const int __ival = static_cast<int>(__value);
     const void* __p0 = std::to_address(__first);
     if (auto __p1 = __builtin_memchr(__p0, __ival, __nu))
       __n = (const char*)__p1 - (const char*)__p0;
   }
      return __first + __n;
    }

 while (__first != __last
     && !(std::__invoke(__proj, *__first) == __value))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      typename _Tp
                                                                >
      requires indirect_binary_predicate<ranges::equal_to,
      projected<iterator_t<_Range>, _Proj>,
      const _Tp*>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__proj));
      }
  };

  inline constexpr __find_fn find{};

  struct __find_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 while (__first != __last
     && !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_fn find_if{};

  struct __find_if_not_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 while (__first != __last
     && (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_not_fn find_if_not{};

  template<typename _Iter1, typename _Iter2>
    struct in_in_result
    {
      [[no_unique_address]] _Iter1 in1;
      [[no_unique_address]] _Iter2 in2;

      template<typename _IIter1, typename _IIter2>
 requires convertible_to<const _Iter1&, _IIter1>
   && convertible_to<const _Iter2&, _IIter2>
 constexpr
 operator in_in_result<_IIter1, _IIter2>() const &
 { return {in1, in2}; }

      template<typename _IIter1, typename _IIter2>
 requires convertible_to<_Iter1, _IIter1>
   && convertible_to<_Iter2, _IIter2>
 constexpr
 operator in_in_result<_IIter1, _IIter2>() &&
 { return {std::move(in1), std::move(in2)}; }
    };

  template<typename _Iter1, typename _Iter2>
    using mismatch_result = in_in_result<_Iter1, _Iter2>;

  struct __mismatch_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr mismatch_result<_Iter1, _Iter2>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2
        && (bool)std::__invoke(__pred,
          std::__invoke(__proj1, *__first1),
          std::__invoke(__proj2, *__first2)))
 {
   ++__first1;
   ++__first2;
 }
 return { std::move(__first1), std::move(__first2) };
      }

    template<input_range _Range1, input_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr mismatch_result<iterator_t<_Range1>, iterator_t<_Range2>>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __mismatch_fn mismatch{};

  struct __search_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr subrange<_Iter1>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if (__first1 == __last1 || __first2 == __last2)
   return {__first1, __first1};

 for (;;)
   {
     for (;;)
       {
  if (__first1 == __last1)
    return {__first1, __first1};
  if (std::__invoke(__pred,
      std::__invoke(__proj1, *__first1),
      std::__invoke(__proj2, *__first2)))
    break;
  ++__first1;
       }
     auto __cur1 = __first1;
     auto __cur2 = __first2;
     for (;;)
       {
  if (++__cur2 == __last2)
    return {__first1, ++__cur1};
  if (++__cur1 == __last1)
    return {__cur1, __cur1};
  if (!(bool)std::__invoke(__pred,
      std::__invoke(__proj1, *__cur1),
      std::__invoke(__proj2, *__cur2)))
    {
      ++__first1;
      break;
    }
       }
   }
      }

    template<forward_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_subrange_t<_Range1>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __search_fn search{};

  struct __min_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __b),
     std::__invoke(__proj, __a)))
   return __b;
 else
   return __a;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>,
         range_value_t<_Range>*>
      constexpr range_value_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false);
 auto __result = *__first;
 while (++__first != __last)
   {
     auto&& __tmp = *__first;
     if (std::__invoke(__comp,
         std::__invoke(__proj, __tmp),
         std::__invoke(__proj, __result)))
       __result = std::forward<decltype(__tmp)>(__tmp);
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr _Tp
      operator()(initializer_list<_Tp> __r,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::subrange(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __min_fn min{};

  struct __adjacent_find_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_binary_predicate<projected<_Iter, _Proj>,
           projected<_Iter, _Proj>> _Pred
        = ranges::equal_to>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return __first;
 auto __next = __first;
 for (; ++__next != __last; __first = __next)
   {
     if (std::__invoke(__pred,
         std::__invoke(__proj, *__first),
         std::__invoke(__proj, *__next)))
       return __first;
   }
 return __next;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_binary_predicate<
        projected<iterator_t<_Range>, _Proj>,
        projected<iterator_t<_Range>, _Proj>> _Pred = ranges::equal_to>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __adjacent_find_fn adjacent_find{};

}

  using ranges::get;

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
    : integral_constant<size_t, 2>
    { };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Iter; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Sent; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Iter; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Sent; };


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 2 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename... _Elements>
    class tuple;


  template<typename _Tp>
    struct __is_empty_non_tuple : is_empty<_Tp> { };


  template<typename _El0, typename... _El>
    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };


  template<typename _Tp>
    using __empty_not_final
    = __conditional_t<__is_final(_Tp), false_type,
        __is_empty_non_tuple<_Tp>>;

  template<size_t _Idx, typename _Head,
    bool = __empty_not_final<_Head>::value>
    struct _Head_base;


  template<size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, true>
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head& __h)
      : _M_head_impl(__h) { }

      constexpr _Head_base(const _Head_base&) = default;
      constexpr _Head_base(_Head_base&&) = default;

      template<typename _UHead>
 constexpr _Head_base(_UHead&& __h)
 : _M_head_impl(std::forward<_UHead>(__h)) { }

      constexpr
      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _M_head_impl(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _M_head_impl(*__a._M_a) { }

      template<typename _UHead>
 constexpr
 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

      [[__no_unique_address__]] _Head _M_head_impl;
    };
# 199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, false>
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head& __h)
      : _M_head_impl(__h) { }

      constexpr _Head_base(const _Head_base&) = default;
      constexpr _Head_base(_Head_base&&) = default;

      template<typename _UHead>
        constexpr _Head_base(_UHead&& __h)
 : _M_head_impl(std::forward<_UHead>(__h)) { }

      constexpr
      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _M_head_impl(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _M_head_impl(*__a._M_a) { }

      template<typename _UHead>
 constexpr
 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

      _Head _M_head_impl;
    };
# 272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<size_t _Idx, typename... _Elements>
    struct _Tuple_impl;






  template<size_t _Idx, typename _Head, typename... _Tail>
    struct _Tuple_impl<_Idx, _Head, _Tail...>
    : public _Tuple_impl<_Idx + 1, _Tail...>,
      private _Head_base<_Idx, _Head>
    {
      template<size_t, typename...> friend struct _Tuple_impl;

      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr _Inherited&
      _M_tail(_Tuple_impl& __t) noexcept { return __t; }

      static constexpr const _Inherited&
      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }

      constexpr _Tuple_impl()
      : _Inherited(), _Base() { }

      explicit constexpr
      _Tuple_impl(const _Head& __head, const _Tail&... __tail)
      : _Inherited(__tail...), _Base(__head)
      { }

      template<typename _UHead, typename... _UTail,
        typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 explicit constexpr
 _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 : _Inherited(std::forward<_UTail>(__tail)...),
   _Base(std::forward<_UHead>(__head))
 { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



      _Tuple_impl& operator=(const _Tuple_impl&) = delete;

      _Tuple_impl(_Tuple_impl&&) = default;

      template<typename... _UElements>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
 { }

      template<typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }
# 368 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Inherited(__tag, __a),
   _Base(__tag, __use_alloc<_Head>(__a))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Head& __head, const _Tail&... __tail)
 : _Inherited(__tag, __a, __tail...),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
 { }

      template<typename _Alloc, typename _UHead, typename... _UTail,
        typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _UHead&& __head, _UTail&&... __tail)
 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(__head))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Tuple_impl& __in)
 : _Inherited(__tag, __a, _M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _Tuple_impl&& __in)
 : _Inherited(__tag, __a, std::move(_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  std::forward<_Head>(_M_head(__in)))
 { }

      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
 : _Inherited(__tag, __a,
       _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(__tag, __a, std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }
# 463 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename... _UElements>
 constexpr
 void
 _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
   _M_tail(*this)._M_assign(
       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
 }

      template<typename _UHead, typename... _UTails>
 constexpr
 void
 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 {
   _M_head(*this) = std::forward<_UHead>
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
   _M_tail(*this)._M_assign(
       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
 }
# 523 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    protected:
      constexpr
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
 _Inherited::_M_swap(_M_tail(__in));
      }
# 542 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    };


  template<size_t _Idx, typename _Head>
    struct _Tuple_impl<_Idx, _Head>
    : private _Head_base<_Idx, _Head>
    {
      template<size_t, typename...> friend struct _Tuple_impl;

      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      constexpr
      _Tuple_impl()
      : _Base() { }

      explicit constexpr
      _Tuple_impl(const _Head& __head)
      : _Base(__head)
      { }

      template<typename _UHead>
 explicit constexpr
 _Tuple_impl(_UHead&& __head)
 : _Base(std::forward<_UHead>(__head))
 { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



      _Tuple_impl& operator=(const _Tuple_impl&) = delete;




      constexpr
      _Tuple_impl(_Tuple_impl&& __in)
      noexcept(is_nothrow_move_constructible<_Head>::value)
      : _Base(static_cast<_Base&&>(__in))
      { }


      template<typename _UHead>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _UHead>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }
# 624 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Base(__tag, __use_alloc<_Head>(__a))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Head& __head)
 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _UHead&& __head)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(__head))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Tuple_impl& __in)
 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _Tuple_impl&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  std::forward<_Head>(_M_head(__in)))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }
# 703 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _UHead>
 constexpr
 void
 _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 }

      template<typename _UHead>
 constexpr
 void
 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
 {
   _M_head(*this)
     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 }
# 749 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    protected:
      constexpr
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
      }
# 766 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    };



  template<bool, typename... _Types>
    struct _TupleConstraints
    {
      template<typename... _UTypes>
 using __constructible = __and_<is_constructible<_Types, _UTypes>...>;

      template<typename... _UTypes>
 using __convertible = __and_<is_convertible<_UTypes, _Types>...>;




      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 {
   return __and_<__constructible<_UTypes...>,
   __convertible<_UTypes...>
   >::value;
 }




      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 {
   return __and_<__constructible<_UTypes...>,
   __not_<__convertible<_UTypes...>>
   >::value;
 }

      static constexpr bool __is_implicitly_default_constructible()
      {
 return __and_<std::__is_implicitly_default_constructible<_Types>...
        >::value;
      }

      static constexpr bool __is_explicitly_default_constructible()
      {
 return __and_<is_default_constructible<_Types>...,
        __not_<__and_<
   std::__is_implicitly_default_constructible<_Types>...>
        >>::value;
      }
    };



  template<typename... _Types>
    struct _TupleConstraints<false, _Types...>
    {
      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 { return false; }

      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 { return false; }
    };



  template<typename... _Elements>
    class tuple : public _Tuple_impl<0, _Elements...>
    {
      using _Inherited = _Tuple_impl<0, _Elements...>;


      template<typename... _UTypes>
 static consteval bool
 __constructible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_constructible<_Elements, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __nothrow_constructible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_nothrow_constructible<_Elements, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __convertible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_convertible<_UTypes, _Elements>...>;
   else
     return false;
 }



      template<typename... _UTypes>
 static consteval bool
 __disambiguating_constraint()
 {
   if constexpr (sizeof...(_Elements) != sizeof...(_UTypes))
     return false;
   else if constexpr (sizeof...(_Elements) == 1)
     {
       using _U0 = typename _Nth_type<0, _UTypes...>::type;
       return !is_same_v<remove_cvref_t<_U0>, tuple>;
     }
   else if constexpr (sizeof...(_Elements) < 4)
     {
       using _U0 = typename _Nth_type<0, _UTypes...>::type;
       if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>)
  return true;
       else
  {
    using _T0 = typename _Nth_type<0, _Elements...>::type;
    return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>;
  }
     }
   return true;
 }




      template<typename _Tuple>
 static consteval bool
 __use_other_ctor()
 {
   if constexpr (sizeof...(_Elements) != 1)
     return false;
   else if constexpr (is_same_v<remove_cvref_t<_Tuple>, tuple>)
     return true;
   else
     {
       using _Tp = typename _Nth_type<0, _Elements...>::type;
       if constexpr (is_convertible_v<_Tuple, _Tp>)
  return true;
       else if constexpr (is_constructible_v<_Tp, _Tuple>)
  return true;
     }
   return false;
 }

      template<typename... _Up>
 static consteval bool
 __dangles()
 {

   return (__reference_constructs_from_temporary(_Elements, _Up&&)
      || ...);



 }
# 960 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    public:
      constexpr
      explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
      tuple()
      noexcept((is_nothrow_default_constructible_v<_Elements> && ...))
      requires (is_default_constructible_v<_Elements> && ...)
      : _Inherited()
      { }


      template<typename = void>
 constexpr explicit(!__convertible<const _Elements&...>())
 tuple(const _Elements&... __elements)
 noexcept(__nothrow_constructible<const _Elements&...>())
 requires (__constructible<const _Elements&...>())
 : _Inherited(__elements...)
 { }

      template<typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(_UTypes&&... __u)
 noexcept(__nothrow_constructible<_UTypes...>())
 : _Inherited(std::forward<_UTypes>(__u)...)
 { }

      template<typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (__dangles<_UTypes...>())
 tuple(_UTypes&&...) = delete;

      constexpr tuple(const tuple&) = default;

      constexpr tuple(tuple&&) = default;

      template<typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (!__dangles<const _UTypes&...>())
 constexpr explicit(!__convertible<const _UTypes&...>())
 tuple(const tuple<_UTypes...>& __u)
 noexcept(__nothrow_constructible<const _UTypes&...>())
 : _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (__dangles<const _UTypes&...>())
 tuple(const tuple<_UTypes...>&) = delete;

      template<typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(tuple<_UTypes...>&& __u)
 noexcept(__nothrow_constructible<_UTypes...>())
 : _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (__dangles<_UTypes...>())
 tuple(tuple<_UTypes...>&&) = delete;
# 1064 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (!__dangles<const _U1&, const _U2&>())
 constexpr explicit(!__convertible<const _U1&, const _U2&>())
 tuple(const pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__u.first, __u.second)
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (__dangles<const _U1&, const _U2&>())
 tuple(const pair<_U1, _U2>&) = delete;

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (!__dangles<_U1, _U2>())
 constexpr explicit(!__convertible<_U1, _U2>())
 tuple(pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__u.first),
       std::forward<_U2>(__u.second))
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (__dangles<_U1, _U2>())
 tuple(pair<_U1, _U2>&&) = delete;
# 1153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _Alloc>
 constexpr
 explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
 tuple(allocator_arg_t __tag, const _Alloc& __a)
 requires (is_default_constructible_v<_Elements> && ...)
 : _Inherited(__tag, __a)
 { }

      template<typename _Alloc>
 constexpr explicit(!__convertible<const _Elements&...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _Elements&... __elements)
 requires (__constructible<const _Elements&...>())
 : _Inherited(__tag, __a, __elements...)
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, _UTypes&&... __u)
 : _Inherited(__tag, __a, std::forward<_UTypes>(__u)...)
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (__dangles<_UTypes...>())
 tuple(allocator_arg_t, const _Alloc&, _UTypes&&...) = delete;

      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __u)
 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__u))
 { }

      template<typename _Alloc>
 requires (__constructible<_Elements...>())
 constexpr
 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __u)
 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (!__dangles<const _UTypes&...>())
 constexpr explicit(!__convertible<const _UTypes&...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_UTypes...>& __u)
 : _Inherited(__tag, __a,
       static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (__dangles<const _UTypes&...>())
 tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&) = delete;

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__use_other_ctor<tuple<_UTypes...>>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>&& __u)
 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (__dangles<_UTypes...>())
 tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&&) = delete;
# 1263 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (!__dangles<const _U1&, const _U2&>())
 constexpr explicit(!__convertible<const _U1&, const _U2&>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__tag, __a, __u.first, __u.second)
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (__dangles<const _U1&, const _U2&>())
 tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&) = delete;

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (!__dangles<_U1, _U2>())
 constexpr explicit(!__convertible<_U1, _U2>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (__dangles<_U1, _U2>())
 tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&&) = delete;
# 1655 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    private:
      template<typename... _UTypes>
 static consteval bool
 __assignable()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_assignable<_Elements&, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __nothrow_assignable()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_nothrow_assignable<_Elements&, _UTypes>...>;
   else
     return false;
 }
# 1708 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    public:

      tuple& operator=(const tuple& __u) = delete;

      constexpr tuple&
      operator=(const tuple& __u)
      noexcept(__nothrow_assignable<const _Elements&...>())
      requires (__assignable<const _Elements&...>())
      {
 this->_M_assign(__u);
 return *this;
      }

      constexpr tuple&
      operator=(tuple&& __u)
      noexcept(__nothrow_assignable<_Elements...>())
      requires (__assignable<_Elements...>())
      {
 this->_M_assign(std::move(__u));
 return *this;
      }

      template<typename... _UTypes>
 requires (__assignable<const _UTypes&...>())
 constexpr tuple&
 operator=(const tuple<_UTypes...>& __u)
 noexcept(__nothrow_assignable<const _UTypes&...>())
 {
   this->_M_assign(__u);
   return *this;
 }

      template<typename... _UTypes>
 requires (__assignable<_UTypes...>())
 constexpr tuple&
 operator=(tuple<_UTypes...>&& __u)
 noexcept(__nothrow_assignable<_UTypes...>())
 {
   this->_M_assign(std::move(__u));
   return *this;
 }
# 1786 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      template<typename _U1, typename _U2>
 requires (__assignable<const _U1&, const _U2&>())
 constexpr tuple&
 operator=(const pair<_U1, _U2>& __u)
 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 {
   this->_M_head(*this) = __u.first;
   this->_M_tail(*this)._M_head(*this) = __u.second;
   return *this;
 }

      template<typename _U1, typename _U2>
 requires (__assignable<_U1, _U2>())
 constexpr tuple&
 operator=(pair<_U1, _U2>&& __u)
 noexcept(__nothrow_assignable<_U1, _U2>())
 {
   this->_M_head(*this) = std::forward<_U1>(__u.first);
   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
   return *this;
 }
# 1948 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
      constexpr
      void
      swap(tuple& __in)
      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
      { _Inherited::_M_swap(__in); }
# 1967 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
    };


  template<typename... _UTypes>
    tuple(_UTypes...) -> tuple<_UTypes...>;
  template<typename _T1, typename _T2>
    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
  template<typename _Alloc, typename _T1, typename _T2>
    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;



  template<>
    class tuple<>
    {
    public:
      constexpr
      void swap(tuple&) noexcept { }





      tuple() = default;

      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t, const _Alloc&) noexcept { }
      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
    };
# 2403 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<typename... _Elements>
    struct tuple_size<tuple<_Elements...>>
    : public integral_constant<size_t, sizeof...(_Elements)> { };


  template<typename... _Types>
    inline constexpr size_t tuple_size_v<tuple<_Types...>>
      = sizeof...(_Types);

  template<typename... _Types>
    inline constexpr size_t tuple_size_v<const tuple<_Types...>>
      = sizeof...(_Types);



  template<size_t __i, typename... _Types>
    struct tuple_element<__i, tuple<_Types...>>
    {
      static_assert(__i < sizeof...(_Types), "tuple index must be in range");

      using type = typename _Nth_type<__i, _Types...>::type;
    };

  template<size_t __i, typename _Head, typename... _Tail>
    constexpr _Head&
    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

  template<size_t __i, typename _Head, typename... _Tail>
    constexpr const _Head&
    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }


  template<size_t __i, typename... _Types>
    __enable_if_t<(__i >= sizeof...(_Types))>
    __get_helper(const tuple<_Types...>&) = delete;


  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
    get(tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
    get(const tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
    get(tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<__element_type>(std::__get_helper<__i>(__t));
    }


  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
    get(const tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<const __element_type>(std::__get_helper<__i>(__t));
    }



  template<size_t __i, typename... _Elements>
    constexpr __enable_if_t<(__i >= sizeof...(_Elements))>
    get(const tuple<_Elements...>&) = delete;




  template <typename _Tp, typename... _Types>
    constexpr _Tp&
    get(tuple<_Types...>& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::__get_helper<__idx>(__t);
    }


  template <typename _Tp, typename... _Types>
    constexpr _Tp&&
    get(tuple<_Types...>&& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::forward<_Tp>(std::__get_helper<__idx>(__t));
    }


  template <typename _Tp, typename... _Types>
    constexpr const _Tp&
    get(const tuple<_Types...>& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::__get_helper<__idx>(__t);
    }



  template <typename _Tp, typename... _Types>
    constexpr const _Tp&&
    get(const tuple<_Types...>&& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
    }



  template<typename... _Tps, typename... _Ups>
    requires (sizeof...(_Tps) == sizeof...(_Ups))
      && (requires (const _Tps& __t, const _Ups& __u) {
 { __t == __u } -> __detail::__boolean_testable;
      } && ...)
    constexpr bool
    operator== [[nodiscard]] (const tuple<_Tps...>& __t,
         const tuple<_Ups...>& __u)
    {
      return [&]<size_t... _Inds>(index_sequence<_Inds...>) {

 return (bool(std::get<_Inds>(__t) == std::get<_Inds>(__u)) && ...);
      }(index_sequence_for<_Tps...>{});
    }

  template<typename _Cat, typename _Tp, typename _Up, typename _IndexSeq>
    [[nodiscard]]
    constexpr _Cat
    __tuple_cmp(const _Tp& __t, const _Up& __u, _IndexSeq __indices)
    {
      _Cat __c = _Cat::equivalent;



      auto __cmp = [&]<size_t _Ind>(integral_constant<size_t, _Ind>) {
 __c = __detail::__synth3way(std::get<_Ind>(__t), std::get<_Ind>(__u));
 return __c == 0;
      };

      [&]<size_t... _Inds>(index_sequence<_Inds...>) {

 (void)(__cmp(integral_constant<size_t, _Inds>{}) && ...);
      }(__indices);

      return __c;
    }

  template<typename... _Tps, typename... _Ups>
    requires (sizeof...(_Tps) == sizeof...(_Ups))
      && (requires { typename __detail::__synth3way_t<_Tps, _Ups>; } && ...)
    constexpr
    common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
    operator<=> [[nodiscard]] (const tuple<_Tps...>& __t,
          const tuple<_Ups...>& __u)
    {
      using _Cat
 = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
      return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
    }
# 2666 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<typename... _Elements>
    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
    make_tuple(_Elements&&... __args)
    {
      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 __result_type;
      return __result_type(std::forward<_Elements>(__args)...);
    }




  template<typename... _Elements>
    constexpr tuple<_Elements&&...>
    forward_as_tuple(_Elements&&... __args) noexcept
    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }


  template<size_t, typename, typename, size_t>
    struct __make_tuple_impl;

  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
    : __make_tuple_impl<_Idx + 1,
   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
   _Tuple, _Nm>
    { };

  template<size_t _Nm, typename _Tuple, typename... _Tp>
    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
    {
      typedef tuple<_Tp...> __type;
    };

  template<typename _Tuple>
    struct __do_make_tuple
    : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
    { };


  template<typename _Tuple>
    struct __make_tuple
    : public __do_make_tuple<__remove_cvref_t<_Tuple>>
    { };


  template<typename...>
    struct __combine_tuples;

  template<>
    struct __combine_tuples<>
    {
      typedef tuple<> __type;
    };

  template<typename... _Ts>
    struct __combine_tuples<tuple<_Ts...>>
    {
      typedef tuple<_Ts...> __type;
    };

  template<typename... _T1s, typename... _T2s, typename... _Rem>
    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
    {
      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
     _Rem...>::__type __type;
    };


  template<typename... _Tpls>
    struct __tuple_cat_result
    {
      typedef typename __combine_tuples
        <typename __make_tuple<_Tpls>::__type...>::__type __type;
    };



  template<typename...>
    struct __make_1st_indices;

  template<>
    struct __make_1st_indices<>
    {
      typedef _Index_tuple<> __type;
    };

  template<typename _Tp, typename... _Tpls>
    struct __make_1st_indices<_Tp, _Tpls...>
    {
      typedef typename _Build_index_tuple<tuple_size<
 typename remove_reference<_Tp>::type>::value>::__type __type;
    };




  template<typename _Ret, typename _Indices, typename... _Tpls>
    struct __tuple_concater;

  template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>
    struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
    {
      template<typename... _Us>
        static constexpr _Ret
        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
        {
   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
   return __next::_S_do(std::forward<_Tpls>(__tps)...,
          std::forward<_Us>(__us)...,
          std::get<_Is>(std::forward<_Tp>(__tp))...);
 }
    };

  template<typename _Ret>
    struct __tuple_concater<_Ret, _Index_tuple<>>
    {
      template<typename... _Us>
 static constexpr _Ret
 _S_do(_Us&&... __us)
        {
   return _Ret(std::forward<_Us>(__us)...);
 }
    };

  template<typename... _Tps>
    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
    { };






  template<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>
    constexpr
    inline


    typename enable_if<__and_<__is_swappable<_Elements>...>::value
      >::type



    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }
# 2848 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<typename... _Elements>
    constexpr
    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;



  template<typename... _Types, typename _Alloc>
    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
# 2867 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
  template<class _T1, class _T2>
    template<typename... _Args1, typename... _Args2>
      constexpr
      inline
      pair<_T1, _T2>::
      pair(piecewise_construct_t,
    tuple<_Args1...> __first, tuple<_Args2...> __second)
      : pair(__first, __second,
      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
      { }

  template<class _T1, class _T2>
    template<typename... _Args1, size_t... _Indexes1,
      typename... _Args2, size_t... _Indexes2>
      constexpr inline
      pair<_T1, _T2>::
      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
      { }






  template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
    inline constexpr bool __unpack_std_tuple = false;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
      = _Trait<_Tp, _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
      = _Trait<_Tp, _Up&...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
      = _Trait<_Tp, const _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
      = _Trait<_Tp, const _Up&...>::value;



  template <typename _Fn, typename _Tuple, size_t... _Idx>
    constexpr decltype(auto)
    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
    {
      return std::__invoke(std::forward<_Fn>(__f),
      std::get<_Idx>(std::forward<_Tuple>(__t))...);
    }




  template <typename _Fn, 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>)
    {
      constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>;

      if constexpr (__n == 1)
 {
   using _Elt = decltype(std::get<0>(std::declval<_Tuple>()));
   static_assert(!__reference_constructs_from_temporary(_Tp, _Elt));
 }

      return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
      make_index_sequence<__n>{});
    }
# 3030 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tuple" 3
}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp>
    concept _Std_pair = __is_pair<remove_cv_t<_Tp>>;




  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         _Args&&... __args) noexcept
    requires (! _Std_pair<_Tp>)
    {
      if constexpr (uses_allocator_v<remove_cv_t<_Tp>, _Alloc>)
 {
   if constexpr (is_constructible_v<_Tp, allocator_arg_t,
        const _Alloc&, _Args...>)
     {
       return tuple<allocator_arg_t, const _Alloc&, _Args&&...>(
    allocator_arg, __a, std::forward<_Args>(__args)...);
     }
   else
     {
       static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>,
    "construction with an allocator must be possible"
    " if uses_allocator is true");

       return tuple<_Args&&..., const _Alloc&>(
    std::forward<_Args>(__args)..., __a);
     }
 }
      else
 {
   static_assert(is_constructible_v<_Tp, _Args...>);

   return tuple<_Args&&...>(std::forward<_Args>(__args)...);
 }
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
         _Tuple1&& __x, _Tuple2&& __y) noexcept;

  template<_Std_pair _Tp, typename _Alloc>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&, _Up&&, _Vp&&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&,
         const pair<_Up, _Vp>&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&, pair<_Up, _Vp>&&) noexcept;
# 120 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 3
  template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
         _Tuple1&& __x, _Tuple2&& __y) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::apply([&__a](auto&&... __args1) {
       return std::uses_allocator_construction_args<_Tp1>(
    __a, std::forward<decltype(__args1)>(__args1)...);
   }, std::forward<_Tuple1>(__x)),
   std::apply([&__a](auto&&... __args2) {
       return std::uses_allocator_construction_args<_Tp2>(
    __a, std::forward<decltype(__args2)>(__args2)...);
   }, std::forward<_Tuple2>(__y)));
    }

  template<_Std_pair _Tp, typename _Alloc>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a),
   std::uses_allocator_construction_args<_Tp2>(__a));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, _Up&& __u, _Vp&& __v)
      noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a,
     std::forward<_Up>(__u)),
   std::uses_allocator_construction_args<_Tp2>(__a,
     std::forward<_Vp>(__v)));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         const pair<_Up, _Vp>& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a, __pr.first),
   std::uses_allocator_construction_args<_Tp2>(__a, __pr.second));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         pair<_Up, _Vp>&& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;




      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a,
     std::get<0>(std::move(__pr))),
   std::uses_allocator_construction_args<_Tp2>(__a,
     std::get<1>(std::move(__pr))));
    }
# 227 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uses_allocator_args.h" 3
  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr _Tp
    make_obj_using_allocator(const _Alloc& __a, _Args&&... __args)
    {
      return std::make_from_tuple<_Tp>(
   std::uses_allocator_construction_args<_Tp>(__a,
     std::forward<_Args>(__args)...));
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr _Tp*
    uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a,
         _Args&&... __args)
    {
      return std::apply([&](auto&&... __xs) {
 return std::construct_at(__p, std::forward<decltype(__xs)>(__xs)...);
      }, std::uses_allocator_construction_args<_Tp>(__a,
 std::forward<_Args>(__args)...));
    }


}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{

namespace pmr
{






  class memory_resource
  {
    static constexpr size_t _S_max_align = alignof(max_align_t);

  public:
    memory_resource() = default;
    memory_resource(const memory_resource&) = default;
    virtual ~memory_resource();

    memory_resource& operator=(const memory_resource&) = default;

    [[nodiscard]]
    void*
    allocate(size_t __bytes, size_t __alignment = _S_max_align)
    __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
    { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); }

    void
    deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align)
    __attribute__((__nonnull__))
    { return do_deallocate(__p, __bytes, __alignment); }

    [[nodiscard]]
    bool
    is_equal(const memory_resource& __other) const noexcept
    { return do_is_equal(__other); }

  private:
    virtual void*
    do_allocate(size_t __bytes, size_t __alignment) = 0;

    virtual void
    do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0;

    virtual bool
    do_is_equal(const memory_resource& __other) const noexcept = 0;
  };

  [[nodiscard]]
  inline bool
  operator==(const memory_resource& __a, const memory_resource& __b) noexcept
  { return &__a == &__b || __a.is_equal(__b); }
# 121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
  template<typename _Tp>
    class polymorphic_allocator
    {


      template<typename _Up>
 struct __not_pair { using type = void; };

      template<typename _Up1, typename _Up2>
 struct __not_pair<pair<_Up1, _Up2>> { };

    public:
      using value_type = _Tp;

      polymorphic_allocator() noexcept
      {
 extern memory_resource* get_default_resource() noexcept
   __attribute__((__returns_nonnull__));
 _M_resource = get_default_resource();
      }

      polymorphic_allocator(memory_resource* __r) noexcept
      __attribute__((__nonnull__))
      : _M_resource(__r)
      { ; }

      polymorphic_allocator(const polymorphic_allocator& __other) = default;

      template<typename _Up>
 polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept
 : _M_resource(__x.resource())
 { }

      polymorphic_allocator&
      operator=(const polymorphic_allocator&) = delete;

      [[nodiscard]]
      _Tp*
      allocate(size_t __n)
      __attribute__((__returns_nonnull__))
      {
 if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Tp)) < __n)
   std::__throw_bad_array_new_length();
 return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp),
             alignof(_Tp)));
      }

      void
      deallocate(_Tp* __p, size_t __n) noexcept
      __attribute__((__nonnull__))
      { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); }


      [[nodiscard]] void*
      allocate_bytes(size_t __nbytes,
       size_t __alignment = alignof(max_align_t))
      { return _M_resource->allocate(__nbytes, __alignment); }

      void
      deallocate_bytes(void* __p, size_t __nbytes,
         size_t __alignment = alignof(max_align_t))
      { _M_resource->deallocate(__p, __nbytes, __alignment); }

      template<typename _Up>
 [[nodiscard]] _Up*
 allocate_object(size_t __n = 1)
 {
   if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Up)) < __n)
     std::__throw_bad_array_new_length();
   return static_cast<_Up*>(allocate_bytes(__n * sizeof(_Up),
        alignof(_Up)));
 }

      template<typename _Up>
 void
 deallocate_object(_Up* __p, size_t __n = 1)
 { deallocate_bytes(__p, __n * sizeof(_Up), alignof(_Up)); }

      template<typename _Up, typename... _CtorArgs>
 [[nodiscard]] _Up*
 new_object(_CtorArgs&&... __ctor_args)
 {
   _Up* __p = allocate_object<_Up>();
   try
     {
       construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
     }
   catch(...)
     {
       deallocate_object(__p);
       throw;
     }
   return __p;
 }

      template<typename _Up>
 void
 delete_object(_Up* __p)
 {
   __p->~_Up();
   deallocate_object(__p);
 }
# 299 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      template<typename _Tp1, typename... _Args>
 __attribute__((__nonnull__))
 void
 construct(_Tp1* __p, _Args&&... __args)
 {
   std::uninitialized_construct_using_allocator(__p, *this,
       std::forward<_Args>(__args)...);
 }


      template<typename _Up>
 __attribute__((__nonnull__))
 void
 destroy(_Up* __p)
 { __p->~_Up(); }

      polymorphic_allocator
      select_on_container_copy_construction() const noexcept
      { return polymorphic_allocator(); }

      memory_resource*
      resource() const noexcept
      __attribute__((__returns_nonnull__))
      { return _M_resource; }



      [[nodiscard]]
      friend bool
      operator==(const polymorphic_allocator& __a,
   const polymorphic_allocator& __b) noexcept
      { return *__a.resource() == *__b.resource(); }
# 340 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
    private:
# 367 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      memory_resource* _M_resource;
    };

  template<typename _Tp1, typename _Tp2>
    [[nodiscard]]
    inline bool
    operator==(const polymorphic_allocator<_Tp1>& __a,
        const polymorphic_allocator<_Tp2>& __b) noexcept
    { return *__a.resource() == *__b.resource(); }
# 386 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
}

  template<typename _Alloc> struct allocator_traits;







  template<typename _Tp>
    struct allocator_traits<pmr::polymorphic_allocator<_Tp>>
    {

      using allocator_type = pmr::polymorphic_allocator<_Tp>;


      using value_type = _Tp;


      using pointer = _Tp*;


      using const_pointer = const _Tp*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;





      using propagate_on_container_copy_assignment = false_type;
      using propagate_on_container_move_assignment = false_type;
      using propagate_on_container_swap = false_type;

      static allocator_type
      select_on_container_copy_construction(const allocator_type&) noexcept
      { return allocator_type(); }



      using is_always_equal = false_type;

      template<typename _Up>
 using rebind_alloc = pmr::polymorphic_allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<pmr::polymorphic_allocator<_Up>>;
# 452 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      [[nodiscard]] static pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 467 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      [[nodiscard]] static pointer
      allocate(allocator_type& __a, size_type __n, const_void_pointer)
      { return __a.allocate(__n); }
# 479 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      static void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 494 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      template<typename _Up, typename... _Args>
 static void
 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
 { __a.construct(__p, std::forward<_Args>(__args)...); }
# 506 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/memory_resource.h" 3
      template<typename _Up>
 static constexpr void
 destroy(allocator_type&, _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 { __p->~_Up(); }





      static constexpr size_type
      max_size(const allocator_type&) noexcept
      { return size_t(-1) / sizeof(value_type); }
    };


}
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/string" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr {
    template<typename _CharT, typename _Traits = char_traits<_CharT>>
      using basic_string = std::basic_string<_CharT, _Traits,
          polymorphic_allocator<_CharT>>;
    using string = basic_string<char>;

    using u8string = basic_string<char8_t>;

    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;
    using wstring = basic_string<wchar_t>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _Predicate>
    constexpr
    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
    erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      const auto __osz = __cont.size();
      const auto __end = __cont.end();
      auto __removed = std::__remove_if(__cont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      __cont.erase(__removed, __end);
      return __osz - __cont.size();
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _Up >
    constexpr
    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
    erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      const auto __osz = __cont.size();
      const auto __end = __cont.end();
      auto __removed = std::__remove_if(__cont.begin(), __end,
     __ops::__iter_equals_val(__value));
      __cont.erase(__removed, __end);
      return __osz - __cont.size();
    }

}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
  class locale
  {
  public:


    typedef int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;

    template<typename _Cache>
      friend struct __use_cache;
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    locale() throw();
# 136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 161 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 172 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    explicit
    locale(const std::string& __s) : locale(__s.c_str()) { }
# 187 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    locale(const locale& __base, const std::string& __s, category __cat)
    : locale(__base, __s.c_str(), __cat) { }
# 202 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 229 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 244 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    template<typename _Facet>
      [[__nodiscard__]]
      locale
      combine(const locale& __other) const;






    [[__nodiscard__]] __attribute ((__abi_tag__ ("cxx11")))
    string
    name() const;
# 275 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    [[__nodiscard__]]
    bool
    operator==(const locale& __other) const throw();
# 307 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    template<typename _Char, typename _Traits, typename _Alloc>
      [[__nodiscard__]]
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
    static locale
    global(const locale& __loc);




    [[__nodiscard__]]
    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 360 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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[];

  };


  template<typename _Tp>
    constexpr bool __is_facet = is_base_of_v<locale::facet, _Tp>;
  template<typename _Tp>
    constexpr bool __is_facet<volatile _Tp> = false;
# 404 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 435 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
# 471 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  };
# 516 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;




    mutable size_t _M_index;


    static _Atomic_word _S_refcount;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }

    size_t
    _M_id() const throw();
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;

    template<typename _Cache>
      friend struct __use_cache;

  private:

    _Atomic_word _M_refcount;
    const facet** _M_facets;
    size_t _M_facets_size;
    const facet** _M_caches;
    char** _M_names;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    void
    _M_add_reference() throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() throw()
    {

                                                           ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
                                                              ;
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      if (_M_names[1])

 for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, const facet*);

    template<typename _Facet>
      void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    template<typename _Facet>
      void
      _M_init_facet_unchecked(_Facet* __facet)
      {
 __facet->_M_add_reference();
 _M_facets[_Facet::id._M_id()] = __facet;
      }

    void
    _M_install_cache(const facet*, size_t);

    void _M_init_extra(facet**);
    void _M_init_extra(void*, void*, const char*, const char*);




  };
# 686 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 713 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 727 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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))
      { }
# 744 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 763 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 777 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 806 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 820 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 833 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.tcc" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"
#pragma GCC diagnostic ignored "-Wvariadic-macros"

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {


      if (__builtin_expect(!__f, 0))
 {
   _M_impl = __other._M_impl;
   _M_impl->_M_add_reference();
   return;
 }

      _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
    {

      static_assert(__is_facet<_Facet>, "Template argument must be a facet");


      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      delete[] __tmp->_M_names[0];
      __tmp->_M_names[0] = 0;
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Facet>
    inline const _Facet*
    __try_use_facet(const locale& __loc) noexcept
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;







      if constexpr (__is_same(const _Facet, const ctype<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const num_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const num_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const codecvt<char, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const collate<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const moneypunct<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const moneypunct<char, true>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const money_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const money_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const numpunct<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const time_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const time_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const messages<char>)) return static_cast<const _Facet*>(__facets[__i]);


      if constexpr (__is_same(const _Facet, const ctype<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const num_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const num_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const codecvt<wchar_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const collate<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const moneypunct<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const moneypunct<wchar_t, true>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const money_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const money_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const numpunct<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const time_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const time_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const messages<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);


      if constexpr (__is_same(const _Facet, const codecvt<char16_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(const _Facet, const codecvt<char32_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);




      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
 return 0;


      return dynamic_cast<const _Facet*>(__facets[__i]);



    }
#pragma GCC diagnostic pop
# 187 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.tcc" 3
  template<typename _Facet>
    [[__nodiscard__]]
    inline bool
    has_facet(const locale& __loc) noexcept
    {

      static_assert(__is_base_of(locale::facet, _Facet),
      "template argument must be derived from locale::facet");



      return std::__try_use_facet<_Facet>(__loc) != 0;
    }
# 215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.tcc" 3
#pragma GCC diagnostic push

  template<typename _Facet>
    [[__nodiscard__]]
    inline const _Facet&
    use_facet(const locale& __loc)
    {

      static_assert(__is_base_of(locale::facet, _Facet),
      "template argument must be derived from locale::facet");



      if (const _Facet* __f = std::__try_use_facet<_Facet>(__loc))
 return *__f;
      __throw_bad_cast();
    }
#pragma GCC diagnostic pop



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
        const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();




      for (;;)
 {
   const int __res = _M_compare(__p, __q);
   if (__res)
     return __res;

   __p += char_traits<_CharT>::length(__p);
   __q += char_traits<_CharT>::length(__q);
   if (__p == __pend && __q == __qend)
     return 0;
   else if (__p == __pend)
     return -1;
   else if (__q == __qend)
     return 1;

   __p++;
   __q++;
 }
    }

  template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {
      string_type __ret;


      const string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      struct _Buf
      {
 _Buf(size_t __n, void* __buf, int __e)
 : _M_c(__buf ? (_CharT*)__buf : new _CharT[__n]),
   _M_stackbuf(__buf),
   _M_errno(__e)
 { }

 ~_Buf()
 {
   if (_M_c != _M_stackbuf)
     delete[] _M_c;
   if ((*__errno_location ()) == 0)
     (*__errno_location ()) = _M_errno;
 }

 void _M_realloc(size_t __len)
 {
   _CharT* __p = new _CharT[__len];
   if (_M_c != _M_stackbuf)
     delete[] _M_c;
   _M_c = __p;
 }

 _CharT* _M_c;
 void* const _M_stackbuf;
 int _M_errno;
      };

      const size_t __bytes = __len * sizeof(_CharT);
      _Buf __buf(__len, __bytes <= 256 ? __builtin_alloca(__bytes) : 0, (*__errno_location ()));
      (*__errno_location ()) = 0;




      for (;;)
 {

   size_t __res = _M_transform(__buf._M_c, __p, __len);


   if (__res >= __len)
     {
       if (__builtin_expect((*__errno_location ()), 0))
  {

    __throw_system_error((*__errno_location ()));







  }

       __len = __res + 1;
       __buf._M_realloc(__len);
       __res = _M_transform(__buf._M_c, __p, __len);
     }

   __ret.append(__buf._M_c, __res);
   __p += char_traits<_CharT>::length(__p);
   if (__p == __pend)
     break;

   __p++;
   __ret.push_back(_CharT());
 }

      return __ret;
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val =
   *__lo + ((__val << 7)
     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
    __digits - 7)));
      return static_cast<long>(__val);
    }




  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const collate<char>*
    __try_use_facet<collate<char> >(const locale&) noexcept;

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);


  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const collate<wchar_t>*
    __try_use_facet<collate<wchar_t> >(const locale&) noexcept;

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);




}

#pragma GCC diagnostic pop
# 897 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_classes.h" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/error_constants.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/error_constants.h" 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
    };


}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stdexcept" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 115 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  };




}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 {
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  public:

    virtual error_condition
    default_error_condition(int __i) const noexcept;


    virtual bool
    equivalent(int __i, const error_condition& __cond) const noexcept;


    virtual bool
    equivalent(const error_code& __code, int __i) const noexcept;


    [[__nodiscard__]]
    bool
    operator==(const error_category& __other) const noexcept
    { return this == &__other; }



    [[nodiscard]]
    strong_ordering
    operator<=>(const error_category& __rhs) const noexcept
    { return std::compare_three_way()(this, &__rhs); }
# 180 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  };




  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  generic_category() noexcept;


  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  system_category() noexcept;



}





namespace __adl_only
{
  void make_error_code() = delete;
  void make_error_condition() = delete;
}
# 225 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  class error_code
  {
    template<typename _ErrorCodeEnum>
      using _Check
 = __enable_if_t<is_error_code_enum<_ErrorCodeEnum>::value>;

  public:
    error_code() noexcept
    : _M_value(0), _M_cat(&system_category()) { }

    error_code(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }


    template<typename _ErrorCodeEnum,
      typename = _Check<_ErrorCodeEnum>>
      error_code(_ErrorCodeEnum __e) noexcept
      {
 using __adl_only::make_error_code;
 *this = make_error_code(__e);
      }

    error_code(const error_code&) = default;
    error_code& operator=(const error_code&) = default;

    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }

    void
    clear() noexcept
    { assign(0, system_category()); }


    [[__nodiscard__]]
    int
    value() const noexcept { return _M_value; }


    [[__nodiscard__]]
    const error_category&
    category() const noexcept { return *_M_cat; }


    error_condition
    default_error_condition() const noexcept;


    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }


    [[__nodiscard__]]
    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };
# 302 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[__nodiscard__]]
  inline error_code
  make_error_code(errc __e) noexcept
  { return error_code(static_cast<int>(__e), generic_category()); }
# 316 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[nodiscard]]
  inline strong_ordering
  operator<=>(const error_code& __lhs, const error_code& __rhs) noexcept
  {
    if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
      return __c;
    return __lhs.value() <=> __rhs.value();
  }
# 339 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
    { return (__os << __e.category().name() << ':' << __e.value()); }
# 356 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  class error_condition
  {
    template<typename _ErrorConditionEnum>
      using _Check
 = __enable_if_t<is_error_condition_enum<_ErrorConditionEnum>::value>;

  public:

    error_condition() noexcept
    : _M_value(0), _M_cat(&generic_category()) { }


    error_condition(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }


    template<typename _ErrorConditionEnum,
      typename = _Check<_ErrorConditionEnum>>
      error_condition(_ErrorConditionEnum __e) noexcept
      {
 using __adl_only::make_error_condition;
 *this = make_error_condition(__e);
      }

    error_condition(const error_condition&) = default;
    error_condition& operator=(const error_condition&) = default;


    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }


    void
    clear() noexcept
    { assign(0, generic_category()); }




    [[__nodiscard__]]
    int
    value() const noexcept { return _M_value; }


    [[__nodiscard__]]
    const error_category&
    category() const noexcept { return *_M_cat; }


    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }


    [[__nodiscard__]]
    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };
# 435 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[__nodiscard__]]
  inline error_condition
  make_error_condition(errc __e) noexcept
  { return error_condition(static_cast<int>(__e), generic_category()); }
# 449 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
  {
    return __lhs.category() == __rhs.category()
      && __lhs.value() == __rhs.value();
  }
# 465 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
  {
    return __lhs.category().equivalent(__lhs.value(), __rhs)
      || __rhs.category().equivalent(__lhs, __rhs.value());
  }
# 480 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_condition& __lhs,
      const error_condition& __rhs) noexcept
  {
    return __lhs.category() == __rhs.category()
      && __lhs.value() == __rhs.value();
  }
# 498 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/system_error" 3
  [[nodiscard]]
  inline strong_ordering
  operator<=>(const error_condition& __lhs,
       const error_condition& __rhs) noexcept
  {
    if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
      return __c;
    return __lhs.value() <=> __rhs.value();
  }
# 558 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
    };



}
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{






  enum _Ios_Fmtflags
    {
      _S_boolalpha = 1L << 0,
      _S_dec = 1L << 1,
      _S_fixed = 1L << 2,
      _S_hex = 1L << 3,
      _S_internal = 1L << 4,
      _S_left = 1L << 5,
      _S_oct = 1L << 6,
      _S_right = 1L << 7,
      _S_scientific = 1L << 8,
      _S_showbase = 1L << 9,
      _S_showpoint = 1L << 10,
      _S_showpos = 1L << 11,
      _S_skipws = 1L << 12,
      _S_unitbuf = 1L << 13,
      _S_uppercase = 1L << 14,
      _S_adjustfield = _S_left | _S_right | _S_internal,
      _S_basefield = _S_dec | _S_oct | _S_hex,
      _S_floatfield = _S_scientific | _S_fixed,
      _S_ios_fmtflags_end = 1L << 16,
      _S_ios_fmtflags_max = 2147483647,
      _S_ios_fmtflags_min = ~2147483647
    };

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a) noexcept
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Fmtflags&
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Fmtflags&
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Fmtflags&
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a ^ __b; }
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
  enum __attribute__((__flag_enum__)) _Ios_Openmode
    {
      _S_app = 1L << 0,
      _S_ate = 1L << 1,
      _S_bin = 1L << 2,
      _S_in = 1L << 3,
      _S_out = 1L << 4,
      _S_trunc = 1L << 5,
      _S_noreplace __attribute__((__unused__)) = 1L << 6,
      _S_ios_openmode_end __attribute__((__unused__)) = 1L << 16,
      _S_ios_openmode_max __attribute__((__unused__)) = 2147483647,
      _S_ios_openmode_min __attribute__((__unused__)) = ~2147483647
    };



  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator~(_Ios_Openmode __a) noexcept
  { return _Ios_Openmode(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Openmode&
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Openmode&
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Openmode&
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a ^ __b; }


  enum _Ios_Iostate
    {
      _S_goodbit = 0,
      _S_badbit = 1L << 0,
      _S_eofbit = 1L << 1,
      _S_failbit = 1L << 2,
      _S_ios_iostate_end = 1L << 16,
      _S_ios_iostate_max = 2147483647,
      _S_ios_iostate_min = ~2147483647
    };

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator~(_Ios_Iostate __a) noexcept
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Iostate&
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Iostate&
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Iostate&
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a ^ __b; }


  enum _Ios_Seekdir
    {
      _S_beg = 0,
      _S_cur = 1,
      _S_end = 2,
      _S_ios_seekdir_end = 1L << 16
    };



  enum class io_errc { stream = 1 };

  template <> struct is_error_code_enum<io_errc> : public true_type { };

  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  iostream_category() noexcept;

  [[__nodiscard__]]
  inline error_code
  make_error_code(io_errc __e) noexcept
  { return error_code(static_cast<int>(__e), iostream_category()); }

  [[__nodiscard__]]
  inline error_condition
  make_error_condition(io_errc __e) noexcept
  { return error_condition(static_cast<int>(__e), iostream_category()); }
# 265 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
  class ios_base
  {
# 283 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
  public:
# 292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
    };
# 378 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 453 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 484 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    typedef _Ios_Openmode openmode;


    static const openmode app = _S_app;


    static const openmode ate = _S_ate;




    static const openmode binary = _S_bin;


    static const openmode in = _S_in;


    static const openmode out = _S_out;


    static const openmode trunc = _S_trunc;

    static const openmode __noreplace = _S_noreplace;
# 523 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 556 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 573 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 585 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };






    [[__nodiscard__]]
    fmtflags
    flags() const
    { return _M_flags; }
# 704 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 720 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 737 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 763 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    [[__nodiscard__]]
    streamsize
    precision() const
    { return _M_precision; }






    streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }







    [[__nodiscard__]]
    streamsize
    width() const
    { return _M_width; }






    streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 816 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 828 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 839 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    [[__nodiscard__]]
    locale
    getloc() const
    { return _M_ios_locale; }
# 851 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 870 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 886 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 907 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 924 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ios_base.h" 3
    virtual ~ios_base();

  protected:
    ios_base() throw ();
# 938 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  }



}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;




      typedef basic_streambuf<char_type, traits_type> __streambuf_type;


      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);

      template<bool _IsMove, typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
        __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
      istreambuf_iterator<_CharT2> >::__type
        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
        advance(istreambuf_iterator<_CharT2>&, _Distance);

      friend void __istream_extract(istream&, char*, streamsize);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
     basic_string<_CharT2, _Traits2, _Alloc>&);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    protected:







      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      locale _M_buf_locale;

  public:

      virtual
      ~basic_streambuf()
      { }
# 217 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      locale
      pubimbue(const locale& __loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 234 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 247 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      basic_streambuf*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }
# 259 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 271 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 306 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 346 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 365 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 380 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 405 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 432 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 458 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 472 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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())
      { }
# 490 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 506 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 517 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 537 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 553 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 563 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 584 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual void
      imbue(const locale& __loc __attribute__ ((__unused__)))
      { }
# 599 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 610 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 622 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 635 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual int
      sync() { return 0; }
# 657 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 673 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 695 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 708 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 732 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual int_type
      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 750 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 776 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 3
      virtual int_type
      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf.tcc" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->__safe_gbump(__len);
     }

   if (__ret < __n)
     {
       const int_type __c = this->uflow();
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    traits_type::assign(*__s++, traits_type::to_char_type(__c));
    ++__ret;
  }
       else
  break;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->epptr() - this->pptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(this->pptr(), __s, __len);
       __ret += __len;
       __s += __len;
       this->__safe_pbump(__len);
     }

   if (__ret < __n)
     {
       int_type __c = this->overflow(traits_type::to_int_type(*__s));
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    ++__ret;
    ++__s;
  }
       else
  break;
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
     basic_streambuf<_CharT, _Traits>* __sbout,
     bool& __ineof)
    {
      streamsize __ret = 0;
      __ineof = true;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   __c = __sbout->sputc(_Traits::to_char_type(__c));
   if (_Traits::eq_int_type(__c, _Traits::eof()))
     {
       __ineof = false;
       break;
     }
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    inline streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      bool __ineof;
      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
    }




  extern template class basic_streambuf<char>;

  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*,
        basic_streambuf<char>*);


  extern template class basic_streambuf<wchar_t>;

  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*,
        basic_streambuf<wchar_t>*);




}

#pragma GCC diagnostic pop
# 863 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/streambuf" 2 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwctype" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 38 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4
# 38 "/usr/include/bits/wctype-wchar.h" 3 4
typedef unsigned long int wctype_t;
# 56 "/usr/include/bits/wctype-wchar.h" 3 4
enum
{
  __ISwupper = 0,
  __ISwlower = 1,
  __ISwalpha = 2,
  __ISwdigit = 3,
  __ISwxdigit = 4,
  __ISwspace = 5,
  __ISwprint = 6,
  __ISwgraph = 7,
  __ISwblank = 8,
  __ISwcntrl = 9,
  __ISwpunct = 10,
  __ISwalnum = 11,

  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};



extern "C" {







extern int iswalnum (wint_t __wc) noexcept (true);





extern int iswalpha (wint_t __wc) noexcept (true);


extern int iswcntrl (wint_t __wc) noexcept (true);



extern int iswdigit (wint_t __wc) noexcept (true);



extern int iswgraph (wint_t __wc) noexcept (true);




extern int iswlower (wint_t __wc) noexcept (true);


extern int iswprint (wint_t __wc) noexcept (true);




extern int iswpunct (wint_t __wc) noexcept (true);




extern int iswspace (wint_t __wc) noexcept (true);




extern int iswupper (wint_t __wc) noexcept (true);




extern int iswxdigit (wint_t __wc) noexcept (true);





extern int iswblank (wint_t __wc) noexcept (true);
# 155 "/usr/include/bits/wctype-wchar.h" 3 4
extern wctype_t wctype (const char *__property) noexcept (true);



extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true);






extern wint_t towlower (wint_t __wc) noexcept (true);


extern wint_t towupper (wint_t __wc) noexcept (true);

}
# 39 "/usr/include/wctype.h" 2 3 4





extern "C" {



typedef const __int32_t *wctrans_t;



extern wctrans_t wctrans (const char *__property) noexcept (true);


extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true);







extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true);





extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true);


extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true);



extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true);



extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true);


extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true);



extern wctype_t wctype_l (const char *__property, locale_t __locale)
     noexcept (true);



extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
     noexcept (true);






extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true);


extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true);



extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
     noexcept (true);


extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
      locale_t __locale) noexcept (true);



}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cwctype" 2 3
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/ctype_base.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

  };


}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf_iterator.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
        _CharT*, _CharT>
    {
    public:
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf_iterator.h" 3
      using pointer = void;


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

      template<bool _IsMove, typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2, typename _Size>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool);

      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        istreambuf_iterator<_CharT2> >::__type
 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
 advance(istreambuf_iterator<_CharT2>&, _Distance);

    private:







      mutable streambuf_type* _M_sbuf;
      int_type _M_c;

    public:

      constexpr istreambuf_iterator() noexcept
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      constexpr istreambuf_iterator(default_sentinel_t) noexcept
      : istreambuf_iterator() { }



      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;

      ~istreambuf_iterator() = default;



      istreambuf_iterator(istream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }


      istreambuf_iterator&
      operator=(const istreambuf_iterator&) noexcept = default;





      [[__nodiscard__]]
      char_type
      operator*() const
      {
 int_type __c = _M_get();
# 163 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf_iterator.h" 3
 return traits_type::to_char_type(__c);
      }


      istreambuf_iterator&
      operator++()
      {



                        ;

 _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {



                        ;

 istreambuf_iterator __old = *this;
 __old._M_c = _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return __old;
      }





      [[__nodiscard__]]
      bool
      equal(const istreambuf_iterator& __b) const
      { return _M_at_eof() == __b._M_at_eof(); }

    private:
      int_type
      _M_get() const
      {
 int_type __ret = _M_c;
 if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
   _M_sbuf = 0;
 return __ret;
      }

      bool
      _M_at_eof() const
      { return _S_is_eof(_M_get()); }

      static bool
      _S_is_eof(int_type __c)
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(__c, __eof);
      }


      [[nodiscard]]
      friend bool
      operator==(const istreambuf_iterator& __i, default_sentinel_t)
      { return __i._M_at_eof(); }

    };

  template<typename _CharT, typename _Traits>
    [[__nodiscard__]]
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }
# 250 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/streambuf_iterator.h" 3
  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:




      using difference_type = ptrdiff_t;

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:


      constexpr
      ostreambuf_iterator() noexcept
      : _M_sbuf(nullptr), _M_failed(true) { }



      ostreambuf_iterator(ostream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


      [[__nodiscard__]]
      ostreambuf_iterator&
      operator*()
      { return *this; }


      ostreambuf_iterator&
      operator++(int)
      { return *this; }


      ostreambuf_iterator&
      operator++()
      { return *this; }


      [[__nodiscard__]]
      bool
      failed() const noexcept
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };
#pragma GCC diagnostic pop


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    copy(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last,
  ostreambuf_iterator<_CharT> __result)
    {
      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 {
   bool __ineof;
   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
   if (!__ineof)
     __result._M_failed = true;
 }
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(_CharT* __first, _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(const _CharT* __first, const _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT> __first,
     istreambuf_iterator<_CharT> __last, _CharT* __result)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
       const streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    traits_type::copy(__result, __sb->gptr(), __n);
    __sb->__safe_gbump(__n);
    __result += __n;
    __c = __sb->underflow();
  }
       else
  {
    *__result++ = traits_type::to_char_type(__c);
    __c = __sb->snextc();
  }
     }
 }
      return __result;
    }

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result,
        bool __strict __attribute__((__unused__)))
    {
      if (__n == 0)
 return __result;



                            ;
      _CharT* __beg = __result;
      __result += __it._M_sbuf->sgetn(__beg, __n);


                            ;
      return __result;
    }

  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
          istreambuf_iterator<_CharT> >::__type
    find(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last, const _CharT& __val)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;
      const int_type __eof = traits_type::eof();

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   const int_type __ival = traits_type::to_int_type(__val);
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, __eof)
   && !traits_type::eq_int_type(__c, __ival))
     {
       streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    const _CharT* __p = traits_type::find(__sb->gptr(),
       __n, __val);
    if (__p)
      __n = __p - __sb->gptr();
    __sb->__safe_gbump(__n);
    __c = __sb->sgetc();
  }
       else
  __c = __sb->snextc();
     }

   __first._M_c = __eof;
 }

      return __first;
    }

  template<typename _CharT, typename _Distance>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        void>::__type
    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
    {
      if (__n == 0)
 return;

      do { if (std::__is_constant_evaluated() && !bool(__n > 0)) std::__glibcxx_assert_fail(); } while (false);


                           ;

      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;
      const int_type __eof = traits_type::eof();

      streambuf_type* __sb = __i._M_sbuf;
      while (__n > 0)
 {
   streamsize __size = __sb->egptr() - __sb->gptr();
   if (__size > __n)
     {
       __sb->__safe_gbump(__n);
       break;
     }

   __sb->__safe_gbump(__size);
   __n -= __size;
   if (traits_type::eq_int_type(__sb->underflow(), __eof))
     {


                      ;
       break;
     }
 }

      __i._M_c = __eof;
    }




}
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 154 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 190 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 206 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 222 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 236 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 251 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 265 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 316 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 357 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 382 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 401 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 420 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 439 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 457 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const = 0;
# 474 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 490 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const = 0;
# 507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 526 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const = 0;
# 547 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
# 568 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const = 0;
# 593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 616 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename __ctype_abstract_base<_CharT>::mask mask;


      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   protected:
      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;



  template<typename _CharT, typename _Traits, typename _Alloc>
    class ctype<basic_string<_CharT, _Traits, _Alloc> >;
# 690 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 727 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 740 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 753 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 768 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 796 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 811 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 828 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 861 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 881 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 908 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 940 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 973 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
# 1023 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1040 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1056 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1073 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1093 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1116 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1143 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
      { return __c; }
# 1169 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 1195 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1239 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
# 1263 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1300 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1352 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1368 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1385 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1405 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const;
# 1427 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1450 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const;
# 1476 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  }


}
# 1549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 {
# 1679 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1717 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1731 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(__cloc); }
# 1745 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1758 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1789 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1802 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1815 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1832 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1857 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1870 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1883 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
    };

}
# 1961 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1982 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 2008 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2045 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      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); }
#pragma GCC diagnostic pop
# 2108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2151 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
 }
# 2224 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      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); }
#pragma GCC diagnostic pop


      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;
# 2279 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      long double&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2307 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2325 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 2346 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2364 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      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); }
#pragma GCC diagnostic pop
# 2472 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2497 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 2545 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      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); }
#pragma GCC diagnostic pop


      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;
# 2600 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;
# 2613 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 3
  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }


  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }


  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }


  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }


  template<typename _CharT>
    inline bool
    islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }


  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }


  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }


  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }


  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }


  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }


  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }



  template<typename _CharT>
    inline bool
    isblank(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }



  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }


  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }


}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.tcc" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

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;
 }
    }
# 143 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 739 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma GCC diagnostic pop

      _UIntPtrType __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      __v = reinterpret_cast<void*>(__ul);
      return __beg;
    }
# 802 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
        __cs, __w, __len);
      __len = static_cast<int>(__w);
    }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __dec)
    {
      _CharT* __buf = __bufend;
      if (__builtin_expect(__dec, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if ((__flags & ios_base::basefield) == ios_base::oct)
 {

   do
     {
       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *--__buf = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
 }
      return __bufend - __buf;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
    {
      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
     __grouping_size, __cs, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;
 const ios_base::fmtflags __flags = __io.flags();


 const int __ilen = 5 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 const bool __dec = (__basefield != ios_base::oct
       && __basefield != ios_base::hex);
 const __unsigned_type __u = ((__v > 0 || !__dec)
         ? __unsigned_type(__v)
         : -__unsigned_type(__v));
  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * (__len + 1)
          * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
     __cs = __cs2 + 2;
   }


 if (__builtin_expect(__dec, true))
   {

     if (__v >= 0)
       {
  if (bool(__flags & ios_base::showpos)
      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (bool(__flags & ios_base::showbase) && __v)
   {
     if (__basefield == ios_base::oct)
       *--__cs = __lit[__num_base::_S_odigits], ++__len;
     else
       {

  const bool __uppercase = __flags & ios_base::uppercase;
  *--__cs = __lit[__num_base::_S_ox + __uppercase];

  *--__cs = __lit[__num_base::_S_odigits];
  __len += 2;
       }
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      const int __declen = __p ? __p - __cs : __len;
      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
      __grouping_size,
      __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 996 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
   }
# 1069 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1194 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;
#pragma GCC diagnostic pop

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<_UIntPtrType>(__v));
      __io.flags(__flags);
      return __s;
    }
# 1243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       streamsize __newlen, streamsize __oldlen)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, __olds, __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   if (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0])
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }
   else if (__ctype.widen('0') == __olds[0]
     && __oldlen > 1
     && (__ctype.widen('x') == __olds[1]
         || __ctype.widen('X') == __olds[1]))
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      size_t __idx = 0;
      size_t __ctr = 0;

      while (__last - __first > __gbeg[__idx]
      && static_cast<signed char>(__gbeg[__idx]) > 0
      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
 {
   __last -= __gbeg[__idx];
   __idx < __gsize - 1 ? ++__idx : ++__ctr;
 }

      while (__first != __last)
 *__s++ = *__first++;

      while (__ctr--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      while (__idx--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      return __s;
    }




  extern template class __cxx11:: numpunct<char>;
  extern template class __cxx11:: numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class ctype_byname<char>;

  extern template
    const ctype<char>*
    __try_use_facet<ctype<char> >(const locale&) noexcept;

  extern template
    const numpunct<char>*
    __try_use_facet<numpunct<char> >(const locale&) noexcept;

  extern template
    const num_put<char>*
    __try_use_facet<num_put<char> >(const locale&) noexcept;

  extern template
    const num_get<char>*
    __try_use_facet<num_get<char> >(const locale&) noexcept;

  extern template
    const ctype<char>&
    use_facet<ctype<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);


  extern template class __cxx11:: numpunct<wchar_t>;
  extern template class __cxx11:: numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class ctype_byname<wchar_t>;

  extern template
    const ctype<wchar_t>*
    __try_use_facet<ctype<wchar_t> >(const locale&) noexcept;

  extern template
    const numpunct<wchar_t>*
    __try_use_facet<numpunct<wchar_t> >(const locale&) noexcept;

  extern template
    const num_put<wchar_t>*
    __try_use_facet<num_put<wchar_t> >(const locale&) noexcept;

  extern template
    const num_get<wchar_t>*
    __try_use_facet<num_get<wchar_t> >(const locale&) noexcept;

  extern template
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);




}

#pragma GCC diagnostic pop
# 2702 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets.h" 2 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {

      static_assert(is_same_v<_CharT, typename _Traits::char_type>);


    public:






      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;






      typedef ctype<_CharT> __ctype_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
           __num_put_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
           __num_get_type;



    protected:
      basic_ostream<_CharT, _Traits>* _M_tie;
      mutable char_type _M_fill;
      mutable bool _M_fill_init;
      basic_streambuf<_CharT, _Traits>* _M_streambuf;


      const __ctype_type* _M_ctype;

      const __num_put_type* _M_num_put;

      const __num_get_type* _M_num_get;

    public:
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      [[__nodiscard__]]
      explicit operator bool() const
      { return !this->fail(); }





      [[__nodiscard__]]
      bool
      operator!() const
      { return this->fail(); }
# 144 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      [[__nodiscard__]]
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 156 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
      }







      [[__nodiscard__]]
      bool
      good() const
      { return this->rdstate() == 0; }







      [[__nodiscard__]]
      bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }
# 211 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      [[__nodiscard__]]
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      [[__nodiscard__]]
      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 234 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      [[__nodiscard__]]
      iostate
      exceptions() const
      { return _M_exception; }
# 270 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      [[__nodiscard__]]
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 321 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }







      [[__nodiscard__]]
      basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }
# 362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 376 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      basic_ios&
      copyfmt(const basic_ios& __rhs);







      [[__nodiscard__]]
      char_type
      fill() const
      {
 if (__builtin_expect(!_M_fill_init, false))
   return this->widen(' ');
 return _M_fill;
      }
# 403 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = _M_fill;
 _M_fill = __ch;
 _M_fill_init = true;
 return __old;
      }
# 424 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 444 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 463 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.tcc" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
 _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != std::__addressof(__rhs))
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.tcc" 3
      if (_M_ctype)
 {
   _M_fill = _M_ctype->widen(' ');
   _M_fill_init = true;
 }
      else
 _M_fill_init = false;

      _M_tie = 0;
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
    {
      _M_ctype = std::__try_use_facet<__ctype_type>(__loc);
      _M_num_put = std::__try_use_facet<__num_put_type>(__loc);
      _M_num_get = std::__try_use_facet<__num_get_type>(__loc);
    }




  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;




}

#pragma GCC diagnostic pop
# 532 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/basic_ios.h" 2 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ios" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
       __num_put_type;
      typedef ctype<_CharT> __ctype_type;
# 91 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 115 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&))
      {



 return __pf(*this);
      }

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&))
      {



 __pf(*this);
 return *this;
      }

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&))
      {



 __pf(*this);
 return *this;
      }
# 173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 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));
      }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      __ostream_type&
      operator<<(long long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long long __n)
      { return _M_insert(__n); }
#pragma GCC diagnostic pop
# 230 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      operator<<(double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(float __f)
      {


 return _M_insert(_S_cast_flt<double>(__f));
      }

      __ostream_type&
      operator<<(long double __f)
      { return _M_insert(__f); }
# 300 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }


      __ostream_type&
      operator<<(nullptr_t)
      { return *this << "nullptr"; }
# 338 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      put(char_type __c);
# 390 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 403 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      flush();
# 413 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      pos_type
      tellp();
# 424 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      __ostream_type&
      seekp(pos_type);
# 436 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      basic_ostream()
      { this->init(0); }



      basic_ostream(basic_iostream<_CharT, _Traits>&) { }

      basic_ostream(const basic_ostream&) = delete;

      basic_ostream(basic_ostream&& __rhs)
      : __ios_type()
      { __ios_type::move(__rhs); }



      basic_ostream& operator=(const basic_ostream&) = delete;

      basic_ostream&
      operator=(basic_ostream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_ostream& __rhs)
      { __ios_type::swap(__rhs); }


      template<typename _ValueT>
 __ostream_type&
 _M_insert(_ValueT __v);

    private:

      void
      _M_write(const char_type* __s, streamsize __n)
      { std::__ostream_insert(*this, __s, __n); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      template<typename _To, typename _From>
 static _To
 _S_cast_flt(_From __f)
 {
   _To __d = static_cast<_To>(__f);
# 507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
   return __d;
 }
#pragma GCC diagnostic pop


      struct _Disable_exceptions
      {
 _Disable_exceptions(basic_ostream& __os)
 : _M_os(__os), _M_exception(_M_os._M_exception)
 { _M_os._M_exception = ios_base::goodbit; }

 ~_Disable_exceptions()
 { _M_os._M_exception = _M_exception; }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"
 _Disable_exceptions(const _Disable_exceptions&) = delete;
 _Disable_exceptions& operator=(const _Disable_exceptions&) = delete;
#pragma GCC diagnostic pop

      private:
 basic_ostream& _M_os;
 const ios_base::iostate _M_exception;
      };
    };
# 540 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT, _Traits>& _M_os;

    public:
# 559 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 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) && _M_os.good()
       && !uncaught_exception())
   {
     _Disable_exceptions __noex(_M_os);
     try
       {


  if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
    _M_os.setstate(ios_base::badbit);
       }
     catch(...)
       { _M_os.setstate(ios_base::badbit); }
   }
      }
#pragma GCC diagnostic pop
# 602 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 624 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    {
      if (__out.width() != 0)
 return __ostream_insert(__out, &__c, 1);
      __out.put(__c);
      return __out;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      if (__out.width() != 0)
 return __ostream_insert(__out, &__c, 1);
      __out.put(__c);
      return __out;
    }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }





  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;

  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;



  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;


  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;

  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
# 715 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }





  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;

  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;



  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;


  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;

  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
# 802 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template<typename _Tp>
    concept __derived_from_ios_base = is_class_v<_Tp>
      && (!is_same_v<_Tp, ios_base>)
      && requires (_Tp* __t, ios_base* __b) { __b = __t; };

  template<typename _Os, typename _Tp>
    requires __derived_from_ios_base<_Os>
      && requires (_Os& __os, const _Tp& __t) { __os << __t; }
    using __rvalue_stream_insertion_t = _Os&&;
# 834 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.h" 3
  template<typename _Ostream, typename _Tp>
    inline __rvalue_stream_insertion_t<_Ostream, _Tp>
    operator<<(_Ostream&& __os, const _Tp& __x)
    {
      __os << __x;
      return std::move(__os);
    }



}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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'))); }
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 _CharT, typename _Traits>
    class __syncbuf_base : public basic_streambuf<_CharT, _Traits>
    {
    public:
      static bool*
      _S_get(basic_streambuf<_CharT, _Traits>* __buf [[maybe_unused]]) noexcept
      {

 if (auto __p = dynamic_cast<__syncbuf_base*>(__buf))
   return &__p->_M_emit_on_sync;

 return nullptr;
      }

    protected:
      __syncbuf_base(basic_streambuf<_CharT, _Traits>* __w = nullptr)
      : _M_wrapped(__w)
      { }

      basic_streambuf<_CharT, _Traits>* _M_wrapped = nullptr;
      bool _M_emit_on_sync = false;
      bool _M_needs_sync = false;
    };

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    emit_on_flush(basic_ostream<_CharT, _Traits>& __os)
    {
      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 *__flag = true;
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    noemit_on_flush(basic_ostream<_CharT, _Traits>& __os)
    {
      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 *__flag = false;
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush_emit(basic_ostream<_CharT, _Traits>& __os)
    {
      struct _Restore
      {
 ~_Restore() { *_M_flag = _M_prev; }

 bool _M_prev = false;
 bool* _M_flag = &_M_prev;
      } __restore;

      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 {
   __restore._M_prev = *__flag;
   __restore._M_flag = __flag;
   *__flag = true;
 }

      __os.flush();
      return __os;
    }
# 292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 3
}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.tcc" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ostream.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else if (__os.bad())
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_ostream<_CharT, _Traits>&
      basic_ostream<_CharT, _Traits>::
      _M_insert(_ValueT __v)
      {
 sentry __cerb(*this);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {

  const __num_put_type& __np = __check_facet(this->_M_num_put);




  if (__np.put(*this, *this, this->fill(), __v).failed())
    __err |= ios_base::badbit;
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(short __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(int __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __put = this->rdbuf()->sputc(__c);
       if (traits_type::eq_int_type(__put, traits_type::eof()))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (this->rdbuf()->sputn(__s, __n) != __n)
  __err = ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(ios_base::badbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {





      if (__streambuf_type* __buf = this->rdbuf())
 {
   sentry __cerb(*this);
   if (__cerb)
     {
       ios_base::iostate __err = ios_base::goodbit;
       try
  {
    if (this->rdbuf()->pubsync() == -1)
      __err |= ios_base::badbit;
  }
       catch(__cxxabiv1::__forced_unwind&)
  {
    this->_M_setstate(ios_base::badbit);
    throw;
  }
       catch(...)
  { this->_M_setstate(ios_base::badbit); }
       if (__err)
  this->setstate(__err);
     }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      sentry __cerb(*this);
      pos_type __ret = pos_type(-1);
      if (!this->fail())
 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      sentry __cerb(*this);
      if (!this->fail())
 {


   const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out);


   if (__p == pos_type(off_type(-1)))
     this->setstate(ios_base::failbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      sentry __cerb(*this);
      if (!this->fail())
 {


   const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
        ios_base::out);


   if (__p == pos_type(off_type(-1)))
     this->setstate(ios_base::failbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 {


   const size_t __clen = char_traits<char>::length(__s);
   try
     {
       struct __ptr_guard
       {
  _CharT *__p;
  __ptr_guard (_CharT *__ip): __p(__ip) { }
  ~__ptr_guard() { delete[] __p; }
  _CharT* __get() { return __p; }
       } __pg (new _CharT[__clen]);

       _CharT *__ws = __pg.__get();
       for (size_t __i = 0; __i < __clen; ++__i)
  __ws[__i] = __out.widen(__s[__i]);
       __ostream_insert(__out, __ws, __clen);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }




  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);

  extern template ostream& ostream::_M_insert(long);
  extern template ostream& ostream::_M_insert(unsigned long);
  extern template ostream& ostream::_M_insert(bool);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
  extern template ostream& ostream::_M_insert(long long);
  extern template ostream& ostream::_M_insert(unsigned long long);
#pragma GCC diagnostic pop

  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);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
  extern template wostream& wostream::_M_insert(long long);
  extern template wostream& wostream::_M_insert(unsigned long long);
#pragma GCC diagnostic pop

  extern template wostream& wostream::_M_insert(double);
  extern template wostream& wostream::_M_insert(long double);
  extern template wostream& wostream::_M_insert(const void*);




}

#pragma GCC diagnostic pop
# 295 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ostream" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 171 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
      __istream_type&
      operator>>(long long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long long& __n)
      { return _M_extract(__n); }
#pragma GCC diagnostic pop
# 220 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 329 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 353 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 363 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 396 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      int_type
      get();
# 410 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      get(char_type& __c);
# 437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 448 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 471 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 481 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 510 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 521 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 545 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      ignore(streamsize __n, int_type __delim);

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore();
# 562 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      int_type
      peek();
# 580 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 599 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 616 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      putback(char_type __c);
# 632 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      unget();
# 650 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      int
      sync();
# 665 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      pos_type
      tellg();
# 680 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      __istream_type&
      seekg(pos_type);
# 696 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 780 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 816 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 827 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 845 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }



  template<typename _CharT, typename _Traits>
    void
    __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize);

  void __istream_extract(istream&, char*, streamsize);
# 952 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
  template<typename _CharT, typename _Traits, size_t _Num>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT (&__s)[_Num])
    {
      static_assert(_Num <= __gnu_cxx::__numeric_traits<streamsize>::__max);
      std::__istream_extract(__in, __s, _Num);
      return __in;
    }

  template<class _Traits, size_t _Num>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char (&__s)[_Num])
    { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }

  template<class _Traits, size_t _Num>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char (&__s)[_Num])
    { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
# 984 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }

    };
# 1067 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
# 1078 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
  template<typename _Is, typename _Tp>
    requires __derived_from_ios_base<_Is>
      && requires (_Is& __is, _Tp&& __t) { __is >> std::forward<_Tp>(__t); }
    using __rvalue_stream_extraction_t = _Is&&;
# 1099 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 3
  template<typename _Istream, typename _Tp>
    inline __rvalue_stream_extraction_t<_Istream, _Tp>
    operator>>(_Istream&& __is, _Tp&& __x)
    {
      __is >> std::forward<_Tp>(__x);
      return std::move(__is);
    }



}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/istream.tcc" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/istream.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"



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);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
       unsigned long long __gcount = 0;
#pragma GCC diagnostic pop

       while (!traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim)
       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  {
    ++__gcount;
    __c = __this_sb->snextc();
    __c2 = traits_type::to_char_type(__c);
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;


       if (__gcount <= __gnu_cxx::__numeric_traits<streamsize>::__max)
  _M_gcount = __gcount;
       else
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              else
                {
                  if (traits_type::eq_int_type(__c, __idelim))
                    {
                      __sb->sbumpc();
                      ++_M_gcount;
                    }
                  else
                    __err |= ios_base::failbit;
                }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }




  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();

       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
  __err |= ios_base::eofbit;
       else
  _M_gcount = 1;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 553 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/istream.tcc" 3
       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
  {
    if (__large_ignore)
      _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
  }
       else if (_M_gcount < __n)
  {
    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();


       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof)
    && !traits_type::eq_int_type(__c, __delim))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
  {
    if (__large_ignore)
      _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
    else
      {
        if (_M_gcount != __n)
   ++_M_gcount;
        __sb->sbumpc();
      }
  }
       else if (_M_gcount < __n)
  {
    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
    else
      {
        ++_M_gcount;
        __sb->sbumpc();
      }
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {

       const streamsize __num = this->rdbuf()->in_avail();
       if (__num > 0)
  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
       else if (__num == -1)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sungetc(), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       if (!this->fail())
  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
        ios_base::in);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const __int_type __cb = __in.rdbuf()->sbumpc();
       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
  __c = _Traits::to_char_type(__cb);
       else
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    void
    __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s,
        streamsize __num)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __width = __in.width();
       if (0 < __width && __width < __num)
  __num = __width;

       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

       const int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       int_type __c = __sb->sgetc();

       while (__extracted < __num - 1
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    *__s++ = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }

       if (__extracted < __num - 1
    && _Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;



       *__s = char_type();
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename __istream_type::int_type __int_type;
      typedef ctype<_CharT> __ctype_type;



      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       while (true)
  {
    if (_Traits::eq_int_type(__c, __eof))
      {
        __err = ios_base::eofbit;
        break;
      }
    if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
      break;
    __c = __sb->snextc();
  }
     }
   catch(const __cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     {
       __in._M_setstate(ios_base::badbit);
     }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"
#pragma GCC diagnostic ignored "-Wlong-long"
  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);

  extern template istream& istream::_M_extract(unsigned short&);
  extern template istream& istream::_M_extract(unsigned int&);
  extern template istream& istream::_M_extract(long&);
  extern template istream& istream::_M_extract(unsigned long&);
  extern template istream& istream::_M_extract(bool&);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
  extern template istream& istream::_M_extract(long long&);
  extern template istream& istream::_M_extract(unsigned long long&);
#pragma GCC diagnostic pop

  extern template istream& istream::_M_extract(float&);
  extern template istream& istream::_M_extract(double&);
  extern template istream& istream::_M_extract(long double&);
  extern template istream& istream::_M_extract(void*&);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template void __istream_extract(wistream&, wchar_t*, streamsize);

  extern template wistream& wistream::_M_extract(unsigned short&);
  extern template wistream& wistream::_M_extract(unsigned int&);
  extern template wistream& wistream::_M_extract(long&);
  extern template wistream& wistream::_M_extract(unsigned long&);
  extern template wistream& wistream::_M_extract(bool&);

  extern template wistream& wistream::_M_extract(long long&);
  extern template wistream& wistream::_M_extract(unsigned long long&);

  extern template wistream& wistream::_M_extract(float&);
  extern template wistream& wistream::_M_extract(double&);
  extern template wistream& wistream::_M_extract(long double&);
  extern template wistream& wistream::_M_extract(void*&);

  extern template class basic_iostream<wchar_t>;

#pragma GCC diagnostic pop



}

#pragma GCC diagnostic pop
# 1112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/istream" 2 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iostream" 3
  __extension__ __asm (".globl _ZSt21ios_base_library_initv");



}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/defs.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 2 3

namespace CLHEP {

class HepRotation;
class HepEulerAngles;
class HepAxisAngle;





class Hep3Vector {

public:



  enum { X=0, Y=1, Z=2, NUM_COORDINATES=3, SIZE=NUM_COORDINATES };



  Hep3Vector();
  explicit Hep3Vector(double x);
  Hep3Vector(double x, double y);
  Hep3Vector(double x, double y, double z);


  inline Hep3Vector(const Hep3Vector &);
  inline Hep3Vector(Hep3Vector &&) = default;


  inline ~Hep3Vector();


  inline double operator () (int) const;


  inline double operator [] (int) const;


  inline double & operator () (int);


  inline double & operator [] (int);


  inline double x() const;
  inline double y() const;
  inline double z() const;


  inline void setX(double);
  inline void setY(double);
  inline void setZ(double);


  inline void set( double x, double y, double z);


  inline double phi() const;


  inline double theta() const;


  inline double cosTheta() const;


  inline double cos2Theta() const;


  inline double mag2() const;


  inline double mag() const;


  inline void setPhi(double);


  inline void setTheta(double);


         void setMag(double);


  inline double perp2() const;


  inline double perp() const;


  inline void setPerp(double);


  void setCylTheta(double);


  inline double perp2(const Hep3Vector &) const;


  inline double perp(const Hep3Vector &) const;


  inline Hep3Vector & operator = (const Hep3Vector &);
  inline Hep3Vector & operator = (Hep3Vector &&) = default;


  inline bool operator == (const Hep3Vector &) const;
  inline bool operator != (const Hep3Vector &) const;


  bool isNear (const Hep3Vector &, double epsilon=tolerance) const;



  double howNear(const Hep3Vector & v ) const;



  double deltaR(const Hep3Vector & v) const;


  inline Hep3Vector & operator += (const Hep3Vector &);


  inline Hep3Vector & operator -= (const Hep3Vector &);


  inline Hep3Vector operator - () const;


  inline Hep3Vector & operator *= (double);


         Hep3Vector & operator /= (double);


  inline Hep3Vector unit() const;


  inline Hep3Vector orthogonal() const;


  inline double dot(const Hep3Vector &) const;


  inline Hep3Vector cross(const Hep3Vector &) const;


  double angle(const Hep3Vector &) const;


  double pseudoRapidity() const;


  void setEta ( double p );


  void setCylEta ( double p );


  Hep3Vector & rotateX(double);


  Hep3Vector & rotateY(double);


  Hep3Vector & rotateZ(double);


  Hep3Vector & rotateUz(const Hep3Vector&);


    Hep3Vector & rotate(double, const Hep3Vector &);



  Hep3Vector & operator *= (const HepRotation &);
  Hep3Vector & transform(const HepRotation &);
# 223 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 3
  inline void setRThetaPhi (double r, double theta, double phi);


  inline void setREtaPhi ( double r, double eta, double phi );


  inline void setRhoPhiZ (double rho, double phi, double z);


  void setRhoPhiTheta ( double rho, double phi, double theta);


  void setRhoPhiEta ( double rho, double phi, double eta);




  inline double getX() const;
  inline double getY() const;
  inline double getZ() const;


  inline double getR () const;
  inline double getTheta() const;
  inline double getPhi () const;


  inline double r () const;


  inline double rho () const;
  inline double getRho () const;


  double eta () const;
  double getEta () const;


  inline void setR ( double s );


  inline void setRho ( double s );




  int compare (const Hep3Vector & v) const;
  bool operator > (const Hep3Vector & v) const;
  bool operator < (const Hep3Vector & v) const;
  bool operator>= (const Hep3Vector & v) const;
  bool operator<= (const Hep3Vector & v) const;


  inline double diff2 (const Hep3Vector & v) const;


  static double setTolerance (double tol);
  static inline double getTolerance ();


  bool isParallel (const Hep3Vector & v, double epsilon=tolerance) const;


  bool isOrthogonal (const Hep3Vector & v, double epsilon=tolerance) const;


  double howParallel (const Hep3Vector & v) const;


  double howOrthogonal (const Hep3Vector & v) const;


  static const int ToleranceTicks = 100;



  double beta () const;



  double gamma() const;


  double coLinearRapidity() const;







  inline double angle() const;


  inline double theta(const Hep3Vector & v2) const;


  double cosTheta (const Hep3Vector & v2) const;
  double cos2Theta(const Hep3Vector & v2) const;


  inline Hep3Vector project () const;
         Hep3Vector project (const Hep3Vector & v2) const;


  inline Hep3Vector perpPart() const;
  inline Hep3Vector perpPart (const Hep3Vector & v2) const;


  double rapidity () const;


  double rapidity (const Hep3Vector & v2) const;



  double eta(const Hep3Vector & v2) const;






  double polarAngle (const Hep3Vector & v2) const;


  double deltaPhi (const Hep3Vector & v2) const;


  double azimAngle (const Hep3Vector & v2) const;


  double polarAngle (const Hep3Vector & v2,
     const Hep3Vector & ref) const;



  double azimAngle (const Hep3Vector & v2,
     const Hep3Vector & ref) const;
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 3
  Hep3Vector & rotate (const Hep3Vector & axis, double delta);


  Hep3Vector & rotate (const HepAxisAngle & ax);


  Hep3Vector & rotate (const HepEulerAngles & e);
  Hep3Vector & rotate (double phi,
                        double theta,
                        double psi);



protected:
  void setSpherical (double r, double theta, double phi);
  void setCylindrical (double r, double phi, double z);
  double negativeInfinity() const;

protected:

  double data[3];


  static double tolerance;

};



Hep3Vector rotationXOf (const Hep3Vector & vec, double delta);
Hep3Vector rotationYOf (const Hep3Vector & vec, double delta);
Hep3Vector rotationZOf (const Hep3Vector & vec, double delta);

Hep3Vector rotationOf (const Hep3Vector & vec,
    const Hep3Vector & axis, double delta);
Hep3Vector rotationOf (const Hep3Vector & vec, const HepAxisAngle & ax);

Hep3Vector rotationOf (const Hep3Vector & vec,
    double phi, double theta, double psi);
Hep3Vector rotationOf (const Hep3Vector & vec, const HepEulerAngles & e);


std::ostream & operator << (std::ostream &, const Hep3Vector &);


std::istream & operator >> (std::istream &, Hep3Vector &);


extern const Hep3Vector HepXHat, HepYHat, HepZHat;

typedef Hep3Vector HepThreeVectorD;
typedef Hep3Vector HepThreeVectorF;

Hep3Vector operator / (const Hep3Vector &, double a);


inline Hep3Vector operator + (const Hep3Vector &, const Hep3Vector &);


inline Hep3Vector operator - (const Hep3Vector &, const Hep3Vector &);


inline double operator * (const Hep3Vector &, const Hep3Vector &);


inline Hep3Vector operator * (const Hep3Vector &, double a);
inline Hep3Vector operator * (double a, const Hep3Vector &);


}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.icc" 1 3
# 10 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.icc" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

# 1 "/usr/include/math.h" 1 3 4
# 27 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/math.h" 2 3 4






extern "C" {





# 1 "/usr/include/bits/math-vector.h" 1 3 4
# 25 "/usr/include/bits/math-vector.h" 3 4
# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
# 26 "/usr/include/bits/math-vector.h" 2 3 4
# 41 "/usr/include/math.h" 2 3 4
# 152 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
# 153 "/usr/include/math.h" 2 3 4
# 163 "/usr/include/math.h" 3 4
typedef float float_t;
typedef double double_t;
# 204 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-logb.h" 1 3 4
# 205 "/usr/include/math.h" 2 3 4
# 247 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-fast.h" 1 3 4
# 248 "/usr/include/math.h" 2 3 4



enum
  {
    FP_INT_UPWARD =

      0,
    FP_INT_DOWNWARD =

      1,
    FP_INT_TOWARDZERO =

      2,
    FP_INT_TONEARESTFROMZERO =

      3,
    FP_INT_TONEAREST =

      4,
  };
# 312 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassify (double __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbit (double __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinf (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finite (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnan (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsig (double __x, double __y) noexcept (true);


extern int __issignaling (double __value) noexcept (true)
     __attribute__ ((__const__));
# 313 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true);

extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true);

extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true);

extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true);


 extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true);

 extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true);

extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true);




extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true);

extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true);

extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true);



 extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true);





extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true);

extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true);

extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true);





 extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true);


extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true);


extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true);


 extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true);


extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true);


extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true);




extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true);


extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true);


extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true);




extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true);


extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true);






 extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true);


extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true);



extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true);




extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true);






extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__));


extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__));


extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__));


extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true);
# 183 "/usr/include/bits/mathcalls.h" 3 4
extern int finite (double __value) noexcept (true)
  __attribute__ ((__const__));


extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true);



extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true);






extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__));




extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true);
extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true);
extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true);
extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true);
extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true);
extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true);





extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true);
extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true);
extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true);




extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true);





extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true);







extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true);






extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true);


extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true);

extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true);




extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true);

extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true);



extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true);



extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true);



extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true);




extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true);




extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true);



extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true);



extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__));



extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true);






extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true);
__extension__
extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true);



extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true);
__extension__
extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true);



extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true);


extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true);




extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalize (double *__cx, const double *__x) noexcept (true);






extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));




extern int totalorder (const double *__x, const double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermag (const double *__x, const double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true);


extern int setpayload (double *__x, double __payload) noexcept (true);


extern int setpayloadsig (double *__x, double __payload) noexcept (true);







extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true);
# 314 "/usr/include/math.h" 2 3 4
# 329 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf (float __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbitf (float __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinff (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finitef (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnanf (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsigf (float __x, float __y) noexcept (true);


extern int __issignalingf (float __value) noexcept (true)
     __attribute__ ((__const__));
# 330 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true);

extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true);

extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true);

extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true);


 extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true);

 extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true);

extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true);




extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true);

extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true);

extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true);



 extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true);





extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true);

extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true);

extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true);





 extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true);


extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true);


extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true);


 extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true);


extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true);


extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true);




extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true);


extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true);


extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true);




extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true);


extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true);






 extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true);


extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true);



extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true);




extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true);






extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__));


extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__));


extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__));


extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true);
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinff (float __value) noexcept (true)
  __attribute__ ((__const__));




extern int finitef (float __value) noexcept (true)
  __attribute__ ((__const__));


extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true);



extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true);






extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__));




extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true);
# 213 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanf (float __value) noexcept (true)
  __attribute__ ((__const__));





extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true);
extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true);
extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true);
extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true);
extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true);
extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true);





extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true);
extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true);
extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true);




extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true);





extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true);







extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true);






extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true);


extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true);

extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true);




extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true);

extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true);



extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true);



extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true);



extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true);




extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true);




extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true);



extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true);



extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__));



extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true);






extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true);
__extension__
extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true);



extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true);
__extension__
extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true);



extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true);


extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true);




extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef (float *__cx, const float *__x) noexcept (true);






extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf (const float *__x, const float *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf (const float *__x, const float *__y) noexcept (true)

     __attribute__ ((__pure__));


extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true);


extern int setpayloadf (float *__x, float __payload) noexcept (true);


extern int setpayloadsigf (float *__x, float __payload) noexcept (true);







extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true);
# 331 "/usr/include/math.h" 2 3 4
# 398 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyl (long double __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbitl (long double __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinfl (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finitel (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnanl (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsigl (long double __x, long double __y) noexcept (true);


extern int __issignalingl (long double __value) noexcept (true)
     __attribute__ ((__const__));
# 399 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true);

extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true);

extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true);

extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true);


 extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true);

 extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true);

extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true);




extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true);

extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true);

extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true);



 extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true);





extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true);

extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true);

extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true);





 extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true);


extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true);


extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true);


 extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true);


extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true);


extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true);




extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true);


extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true);


extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true);




extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true);


extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true);






 extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true);


extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true);



extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true);




extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true);






extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true);
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) noexcept (true)
  __attribute__ ((__const__));




extern int finitel (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true);



extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true);






extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));




extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true);
# 213 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanl (long double __value) noexcept (true)
  __attribute__ ((__const__));





extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true);
extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true);
extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true);
extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true);
extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true);
extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true);





extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true);
extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true);
extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true);




extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true);





extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true);







extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true);






extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true);


extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true);

extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true);




extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true);

extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true);



extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true);



extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true);



extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true);




extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true);




extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true);



extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true);



extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__));



extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true);






extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true);
__extension__
extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true);



extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true);
__extension__
extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true);



extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true);


extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true);




extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true);






extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderl (const long double *__x, const long double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true);


extern int setpayloadl (long double *__x, long double __payload) noexcept (true);


extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true);







extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true);
# 400 "/usr/include/math.h" 2 3 4
# 450 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true);

extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true);

extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true);

extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true);


 extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true);

 extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true);

extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true);




extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true);

extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true);

extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true);



 extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true);





extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true);

extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true);

extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true);





 extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true);


extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true);


extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true);


 extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true);


extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true);


extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true);




extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true);


extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true);


extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true);




extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true);


extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true);






 extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true);


extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true);



extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true);




extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true);






extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));




extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true);
extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true);
extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true);
extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true);
extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true);
extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true);





extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true);
extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true);
extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true);




extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true);






extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true);


extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true);






extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true);

extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true);



extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true);



extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true);



extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true);




extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true);




extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true);



extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true);



extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));



extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));




extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true);






extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true);
__extension__
extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true);



extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true);
__extension__
extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true);



extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true);


extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true);




extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true);






extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true);


extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true);


extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true);
# 451 "/usr/include/math.h" 2 3 4
# 467 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true);

extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true);

extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true);

extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true);


 extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true);

 extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true);

extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true);




extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true);

extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true);

extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true);



 extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true);





extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true);

extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true);

extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true);





 extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true);


extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true);


extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true);


 extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true);


extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true);


extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true);




extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true);


extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true);


extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true);




extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true);


extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true);






 extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true);



extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true);




extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true);






extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));




extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true);
extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true);
extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true);
extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true);
extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true);
extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true);





extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true);
extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true);
extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true);




extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true);






extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true);


extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true);






extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true);

extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true);



extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true);



extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true);



extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true);




extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true);




extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true);



extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true);



extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));



extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));




extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true);






extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true);
__extension__
extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true);



extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true);
__extension__
extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true);



extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true);




extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true);






extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true);


extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true);


extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true);
# 468 "/usr/include/math.h" 2 3 4
# 501 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true);

extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true);

extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true);

extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true);


 extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true);

 extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true);

extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true);




extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true);

extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true);

extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true);



 extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true);





extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true);

extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true);

extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true);





 extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true);


extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true);


extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true);


 extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true);


extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true);


extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true);




extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true);


extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true);


extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true);




extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true);


extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true);






 extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true);



extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true);




extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true);






extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));




extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true);
extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true);
extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true);
extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true);
extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true);
extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true);





extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true);
extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true);
extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true);




extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true);






extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true);


extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true);






extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true);

extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true);



extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true);



extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true);



extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true);




extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true);




extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true);



extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true);



extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));



extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));




extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true);






extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true);
__extension__
extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true);



extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true);
__extension__
extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true);



extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true);




extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true);






extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true);


extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true);


extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true);
# 502 "/usr/include/math.h" 2 3 4
# 518 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true);

extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true);

extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true);

extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true);


 extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true);

 extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true);

extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true);




extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true);

extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true);

extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true);



 extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true);





extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true);

extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true);

extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true);





 extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true);


extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true);


extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true);


 extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true);


extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true);


extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true);




extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true);


extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true);


extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true);




extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true);


extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true);






 extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true);



extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true);




extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true);






extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));




extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true);
extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true);
extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true);
extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true);
extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true);
extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true);





extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true);
extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true);
extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true);




extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true);






extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true);


extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true);






extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true);

extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true);



extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true);



extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true);



extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true);




extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true);




extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true);



extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true);



extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));



extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));




extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true);






extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true);
__extension__
extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true);



extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true);
__extension__
extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true);



extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);




extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true);






extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true);


extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true);


extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true);
# 519 "/usr/include/math.h" 2 3 4
# 566 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern float fadd (double __x, double __y) noexcept (true);


extern float fdiv (double __x, double __y) noexcept (true);


extern float fmul (double __x, double __y) noexcept (true);


extern float fsub (double __x, double __y) noexcept (true);
# 567 "/usr/include/math.h" 2 3 4
# 585 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern float faddl (long double __x, long double __y) noexcept (true);


extern float fdivl (long double __x, long double __y) noexcept (true);


extern float fmull (long double __x, long double __y) noexcept (true);


extern float fsubl (long double __x, long double __y) noexcept (true);
# 586 "/usr/include/math.h" 2 3 4
# 611 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern double daddl (long double __x, long double __y) noexcept (true);


extern double ddivl (long double __x, long double __y) noexcept (true);


extern double dmull (long double __x, long double __y) noexcept (true);


extern double dsubl (long double __x, long double __y) noexcept (true);
# 612 "/usr/include/math.h" 2 3 4
# 691 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true);
# 692 "/usr/include/math.h" 2 3 4
# 701 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 702 "/usr/include/math.h" 2 3 4
# 711 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 712 "/usr/include/math.h" 2 3 4
# 741 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 742 "/usr/include/math.h" 2 3 4
# 751 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 752 "/usr/include/math.h" 2 3 4
# 781 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 782 "/usr/include/math.h" 2 3 4
# 848 "/usr/include/math.h" 3 4
extern int signgam;
# 928 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 1048 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/iscanonical.h" 1 3 4
# 23 "/usr/include/bits/iscanonical.h" 3 4
extern int __iscanonicall (long double __x)
     noexcept (true) __attribute__ ((__const__));
# 46 "/usr/include/bits/iscanonical.h" 3 4
extern "C++" {
inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (long double __val) { return __iscanonicall (__val); }



}
# 1049 "/usr/include/math.h" 2 3 4
# 1060 "/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);

}





}
# 1091 "/usr/include/math.h" 3 4
extern "C++" {
# 1122 "/usr/include/math.h" 3 4
template <class __T> inline bool
iszero (__T __val)
{
  return __val == 0;
}

}
# 1340 "/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);



  }
};
# 1383 "/usr/include/math.h" 3 4
template<typename _T1, typename _T2>
inline int
iseqsig (_T1 __x, _T2 __y) throw ()
{

  typedef decltype (((__x) + (__y) + 0.0f)) _T3;



  return __iseqsig_type<_T3>::__call (__x, __y);
}

}




}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 2 3

#pragma GCC diagnostic pop





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 2 3
# 90 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::acos;


  inline constexpr float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline constexpr long double
  acos(long double __x)
  { return __builtin_acosl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;


  inline constexpr float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline constexpr long double
  asin(long double __x)
  { return __builtin_asinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;


  inline constexpr float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline constexpr long double
  atan(long double __x)
  { return __builtin_atanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;


  inline constexpr float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline constexpr long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }


  using ::ceil;


  inline constexpr float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline constexpr long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;


  inline constexpr float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline constexpr long double
  cos(long double __x)
  { return __builtin_cosl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;


  inline constexpr float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline constexpr long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;


  inline constexpr float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline constexpr long double
  exp(long double __x)
  { return __builtin_expl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;


  inline constexpr float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline constexpr long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;


  inline constexpr float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline constexpr long double
  floor(long double __x)
  { return __builtin_floorl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;


  inline constexpr float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline constexpr long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }


  using ::frexp;


  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;


  inline constexpr float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline constexpr long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ldexp(_Tp __x, int __exp)
    { return __builtin_ldexp(__x, __exp); }

  using ::log;


  inline constexpr float
  log(float __x)
  { return __builtin_logf(__x); }

  inline constexpr long double
  log(long double __x)
  { return __builtin_logl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;


  inline constexpr float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline constexpr long double
  log10(long double __x)
  { return __builtin_log10l(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;


  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }


  using ::pow;


  inline constexpr float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline constexpr long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }
# 407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  using ::sin;


  inline constexpr float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline constexpr long double
  sin(long double __x)
  { return __builtin_sinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;


  inline constexpr float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline constexpr long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;


  inline constexpr float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline constexpr long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;


  inline constexpr float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline constexpr long double
  tan(long double __x)
  { return __builtin_tanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;


  inline constexpr float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline constexpr long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }
# 1060 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    atan2(_Tp __y, _Up __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return atan2(__type(__y), __type(__x));
    }

  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmod(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmod(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    pow(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return pow(__type(__x), __type(__y));
    }
# 1107 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  constexpr int
  fpclassify(float __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }

  constexpr int
  fpclassify(double __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }

  constexpr int
  fpclassify(long double __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              int>::__type
    fpclassify(_Tp __x)
    { return __x != 0 ? 4 : 2; }



  constexpr bool
  isfinite(float __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(double __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(long double __x)
  { return __builtin_isfinite(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isfinite(_Tp)
    { return true; }



  constexpr bool
  isinf(float __x)
  { return __builtin_isinf(__x); }





  constexpr bool
  isinf(double __x)
  { return __builtin_isinf(__x); }


  constexpr bool
  isinf(long double __x)
  { return __builtin_isinf(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isinf(_Tp)
    { return false; }



  constexpr bool
  isnan(float __x)
  { return __builtin_isnan(__x); }





  constexpr bool
  isnan(double __x)
  { return __builtin_isnan(__x); }


  constexpr bool
  isnan(long double __x)
  { return __builtin_isnan(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnan(_Tp)
    { return false; }



  constexpr bool
  isnormal(float __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(double __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(long double __x)
  { return __builtin_isnormal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnormal(_Tp __x)
    { return __x != 0 ? true : false; }




  constexpr bool
  signbit(float __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(double __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(long double __x)
  { return __builtin_signbit(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    signbit(_Tp __x)
    { return __x < 0 ? true : false; }



  constexpr bool
  isgreater(float __x, float __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(double __x, double __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(long double __x, long double __y)
  { return __builtin_isgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isgreaterequal(float __x, float __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(double __x, double __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(long double __x, long double __y)
  { return __builtin_isgreaterequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreaterequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreaterequal(__type(__x), __type(__y));
    }



  constexpr bool
  isless(float __x, float __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(double __x, double __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(long double __x, long double __y)
  { return __builtin_isless(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isless(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isless(__type(__x), __type(__y));
    }



  constexpr bool
  islessequal(float __x, float __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(double __x, double __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(long double __x, long double __y)
  { return __builtin_islessequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessequal(__type(__x), __type(__y));
    }



  constexpr bool
  islessgreater(float __x, float __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(double __x, double __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(long double __x, long double __y)
  { return __builtin_islessgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isunordered(float __x, float __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(double __x, double __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(long double __x, long double __y)
  { return __builtin_isunordered(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isunordered(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isunordered(__type(__x), __type(__y));
    }
# 1827 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  using ::acosf;


  using ::acosl;



  using ::asinf;


  using ::asinl;



  using ::atanf;


  using ::atanl;



  using ::atan2f;


  using ::atan2l;



  using ::ceilf;


  using ::ceill;



  using ::cosf;


  using ::cosl;



  using ::coshf;


  using ::coshl;



  using ::expf;


  using ::expl;



  using ::fabsf;


  using ::fabsl;



  using ::floorf;


  using ::floorl;



  using ::fmodf;


  using ::fmodl;



  using ::frexpf;


  using ::frexpl;



  using ::ldexpf;


  using ::ldexpl;



  using ::logf;


  using ::logl;



  using ::log10f;


  using ::log10l;



  using ::modff;


  using ::modfl;



  using ::powf;


  using ::powl;



  using ::sinf;


  using ::sinl;



  using ::sinhf;


  using ::sinhl;



  using ::sqrtf;


  using ::sqrtl;



  using ::tanf;


  using ::tanl;



  using ::tanhf;


  using ::tanhl;
# 2092 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  using ::double_t;
  using ::float_t;



  using ::acosh;
  using ::acoshf;
  using ::acoshl;

  using ::asinh;
  using ::asinhf;
  using ::asinhl;

  using ::atanh;
  using ::atanhf;
  using ::atanhl;

  using ::cbrt;
  using ::cbrtf;
  using ::cbrtl;

  using ::copysign;
  using ::copysignf;
  using ::copysignl;

  using ::erf;
  using ::erff;
  using ::erfl;

  using ::erfc;
  using ::erfcf;
  using ::erfcl;

  using ::exp2;
  using ::exp2f;
  using ::exp2l;

  using ::expm1;
  using ::expm1f;
  using ::expm1l;

  using ::fdim;
  using ::fdimf;
  using ::fdiml;

  using ::fma;
  using ::fmaf;
  using ::fmal;

  using ::fmax;
  using ::fmaxf;
  using ::fmaxl;

  using ::fmin;
  using ::fminf;
  using ::fminl;

  using ::hypot;
  using ::hypotf;
  using ::hypotl;

  using ::ilogb;
  using ::ilogbf;
  using ::ilogbl;

  using ::lgamma;
  using ::lgammaf;
  using ::lgammal;


  using ::llrint;
  using ::llrintf;
  using ::llrintl;

  using ::llround;
  using ::llroundf;
  using ::llroundl;


  using ::log1p;
  using ::log1pf;
  using ::log1pl;

  using ::log2;
  using ::log2f;
  using ::log2l;

  using ::logb;
  using ::logbf;
  using ::logbl;

  using ::lrint;
  using ::lrintf;
  using ::lrintl;

  using ::lround;
  using ::lroundf;
  using ::lroundl;

  using ::nan;
  using ::nanf;
  using ::nanl;

  using ::nearbyint;
  using ::nearbyintf;
  using ::nearbyintl;

  using ::nextafter;
  using ::nextafterf;
  using ::nextafterl;

  using ::nexttoward;
  using ::nexttowardf;
  using ::nexttowardl;

  using ::remainder;
  using ::remainderf;
  using ::remainderl;

  using ::remquo;
  using ::remquof;
  using ::remquol;

  using ::rint;
  using ::rintf;
  using ::rintl;

  using ::round;
  using ::roundf;
  using ::roundl;

  using ::scalbln;
  using ::scalblnf;
  using ::scalblnl;

  using ::scalbn;
  using ::scalbnf;
  using ::scalbnl;

  using ::tgamma;
  using ::tgammaf;
  using ::tgammal;

  using ::trunc;
  using ::truncf;
  using ::truncl;



  constexpr float
  acosh(float __x)
  { return __builtin_acoshf(__x); }

  constexpr long double
  acosh(long double __x)
  { return __builtin_acoshl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    acosh(_Tp __x)
    { return __builtin_acosh(__x); }



  constexpr float
  asinh(float __x)
  { return __builtin_asinhf(__x); }

  constexpr long double
  asinh(long double __x)
  { return __builtin_asinhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    asinh(_Tp __x)
    { return __builtin_asinh(__x); }



  constexpr float
  atanh(float __x)
  { return __builtin_atanhf(__x); }

  constexpr long double
  atanh(long double __x)
  { return __builtin_atanhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    atanh(_Tp __x)
    { return __builtin_atanh(__x); }



  constexpr float
  cbrt(float __x)
  { return __builtin_cbrtf(__x); }

  constexpr long double
  cbrt(long double __x)
  { return __builtin_cbrtl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    cbrt(_Tp __x)
    { return __builtin_cbrt(__x); }



  constexpr float
  copysign(float __x, float __y)
  { return __builtin_copysignf(__x, __y); }

  constexpr long double
  copysign(long double __x, long double __y)
  { return __builtin_copysignl(__x, __y); }



  constexpr float
  erf(float __x)
  { return __builtin_erff(__x); }

  constexpr long double
  erf(long double __x)
  { return __builtin_erfl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erf(_Tp __x)
    { return __builtin_erf(__x); }



  constexpr float
  erfc(float __x)
  { return __builtin_erfcf(__x); }

  constexpr long double
  erfc(long double __x)
  { return __builtin_erfcl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erfc(_Tp __x)
    { return __builtin_erfc(__x); }



  constexpr float
  exp2(float __x)
  { return __builtin_exp2f(__x); }

  constexpr long double
  exp2(long double __x)
  { return __builtin_exp2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    exp2(_Tp __x)
    { return __builtin_exp2(__x); }



  constexpr float
  expm1(float __x)
  { return __builtin_expm1f(__x); }

  constexpr long double
  expm1(long double __x)
  { return __builtin_expm1l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    expm1(_Tp __x)
    { return __builtin_expm1(__x); }



  constexpr float
  fdim(float __x, float __y)
  { return __builtin_fdimf(__x, __y); }

  constexpr long double
  fdim(long double __x, long double __y)
  { return __builtin_fdiml(__x, __y); }



  constexpr float
  fma(float __x, float __y, float __z)
  { return __builtin_fmaf(__x, __y, __z); }

  constexpr long double
  fma(long double __x, long double __y, long double __z)
  { return __builtin_fmal(__x, __y, __z); }



  constexpr float
  fmax(float __x, float __y)
  { return __builtin_fmaxf(__x, __y); }

  constexpr long double
  fmax(long double __x, long double __y)
  { return __builtin_fmaxl(__x, __y); }



  constexpr float
  fmin(float __x, float __y)
  { return __builtin_fminf(__x, __y); }

  constexpr long double
  fmin(long double __x, long double __y)
  { return __builtin_fminl(__x, __y); }



  constexpr float
  hypot(float __x, float __y)
  { return __builtin_hypotf(__x, __y); }

  constexpr long double
  hypot(long double __x, long double __y)
  { return __builtin_hypotl(__x, __y); }



  constexpr int
  ilogb(float __x)
  { return __builtin_ilogbf(__x); }

  constexpr int
  ilogb(long double __x)
  { return __builtin_ilogbl(__x); }



  template<typename _Tp>
    constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    int>::__type
    ilogb(_Tp __x)
    { return __builtin_ilogb(__x); }



  constexpr float
  lgamma(float __x)
  { return __builtin_lgammaf(__x); }

  constexpr long double
  lgamma(long double __x)
  { return __builtin_lgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    lgamma(_Tp __x)
    { return __builtin_lgamma(__x); }



  constexpr long long
  llrint(float __x)
  { return __builtin_llrintf(__x); }

  constexpr long long
  llrint(long double __x)
  { return __builtin_llrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llrint(_Tp __x)
    { return __builtin_llrint(__x); }



  constexpr long long
  llround(float __x)
  { return __builtin_llroundf(__x); }

  constexpr long long
  llround(long double __x)
  { return __builtin_llroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llround(_Tp __x)
    { return __builtin_llround(__x); }



  constexpr float
  log1p(float __x)
  { return __builtin_log1pf(__x); }

  constexpr long double
  log1p(long double __x)
  { return __builtin_log1pl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log1p(_Tp __x)
    { return __builtin_log1p(__x); }




  constexpr float
  log2(float __x)
  { return __builtin_log2f(__x); }

  constexpr long double
  log2(long double __x)
  { return __builtin_log2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log2(_Tp __x)
    { return __builtin_log2(__x); }



  constexpr float
  logb(float __x)
  { return __builtin_logbf(__x); }

  constexpr long double
  logb(long double __x)
  { return __builtin_logbl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    logb(_Tp __x)
    { return __builtin_logb(__x); }



  constexpr long
  lrint(float __x)
  { return __builtin_lrintf(__x); }

  constexpr long
  lrint(long double __x)
  { return __builtin_lrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lrint(_Tp __x)
    { return __builtin_lrint(__x); }



  constexpr long
  lround(float __x)
  { return __builtin_lroundf(__x); }

  constexpr long
  lround(long double __x)
  { return __builtin_lroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lround(_Tp __x)
    { return __builtin_lround(__x); }



  constexpr float
  nearbyint(float __x)
  { return __builtin_nearbyintf(__x); }

  constexpr long double
  nearbyint(long double __x)
  { return __builtin_nearbyintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nearbyint(_Tp __x)
    { return __builtin_nearbyint(__x); }



  constexpr float
  nextafter(float __x, float __y)
  { return __builtin_nextafterf(__x, __y); }

  constexpr long double
  nextafter(long double __x, long double __y)
  { return __builtin_nextafterl(__x, __y); }



  constexpr float
  nexttoward(float __x, long double __y)
  { return __builtin_nexttowardf(__x, __y); }

  constexpr long double
  nexttoward(long double __x, long double __y)
  { return __builtin_nexttowardl(__x, __y); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nexttoward(_Tp __x, long double __y)
    { return __builtin_nexttoward(__x, __y); }



  constexpr float
  remainder(float __x, float __y)
  { return __builtin_remainderf(__x, __y); }

  constexpr long double
  remainder(long double __x, long double __y)
  { return __builtin_remainderl(__x, __y); }



  inline float
  remquo(float __x, float __y, int* __pquo)
  { return __builtin_remquof(__x, __y, __pquo); }

  inline long double
  remquo(long double __x, long double __y, int* __pquo)
  { return __builtin_remquol(__x, __y, __pquo); }



  constexpr float
  rint(float __x)
  { return __builtin_rintf(__x); }

  constexpr long double
  rint(long double __x)
  { return __builtin_rintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    rint(_Tp __x)
    { return __builtin_rint(__x); }



  constexpr float
  round(float __x)
  { return __builtin_roundf(__x); }

  constexpr long double
  round(long double __x)
  { return __builtin_roundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    round(_Tp __x)
    { return __builtin_round(__x); }



  constexpr float
  scalbln(float __x, long __ex)
  { return __builtin_scalblnf(__x, __ex); }

  constexpr long double
  scalbln(long double __x, long __ex)
  { return __builtin_scalblnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbln(_Tp __x, long __ex)
    { return __builtin_scalbln(__x, __ex); }



  constexpr float
  scalbn(float __x, int __ex)
  { return __builtin_scalbnf(__x, __ex); }

  constexpr long double
  scalbn(long double __x, int __ex)
  { return __builtin_scalbnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbn(_Tp __x, int __ex)
    { return __builtin_scalbn(__x, __ex); }



  constexpr float
  tgamma(float __x)
  { return __builtin_tgammaf(__x); }

  constexpr long double
  tgamma(long double __x)
  { return __builtin_tgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    tgamma(_Tp __x)
    { return __builtin_tgamma(__x); }



  constexpr float
  trunc(float __x)
  { return __builtin_truncf(__x); }

  constexpr long double
  trunc(long double __x)
  { return __builtin_truncl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    trunc(_Tp __x)
    { return __builtin_trunc(__x); }
# 3689 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    copysign(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return copysign(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fdim(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fdim(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmax(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmax(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmin(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmin(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    hypot(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return hypot(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    nextafter(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return nextafter(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remainder(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remainder(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remquo(_Tp __x, _Up __y, int* __pquo)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remquo(__type(__x), __type(__y), __pquo);
    }

  template<typename _Tp, typename _Up, typename _Vp>
    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
    fma(_Tp __x, _Up __y, _Vp __z)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
      return fma(__type(__x), __type(__y), __type(__z));
    }







  template<typename _Tp>
    inline _Tp
    __hypot3(_Tp __x, _Tp __y, _Tp __z)
    {
      __x = std::abs(__x);
      __y = std::abs(__y);
      __z = std::abs(__z);
      if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
 return __a * std::sqrt((__x / __a) * (__x / __a)
          + (__y / __a) * (__y / __a)
          + (__z / __a) * (__z / __a));
      else
 return {};
    }

  inline float
  hypot(float __x, float __y, float __z)
  { return std::__hypot3<float>(__x, __y, __z); }

  inline double
  hypot(double __x, double __y, double __z)
  { return std::__hypot3<double>(__x, __y, __z); }

  inline long double
  hypot(long double __x, long double __y, long double __z)
  { return std::__hypot3<long double>(__x, __y, __z); }

  template<typename _Tp, typename _Up, typename _Vp>
    __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
    hypot(_Tp __x, _Up __y, _Vp __z)
    {
      using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
      return std::__hypot3<__type>(__x, __y, __z);
    }
# 3838 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
  template<typename _Fp>
    constexpr _Fp
    __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
    {
      if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
 return __t * __b + (1 - __t) * __a;

      if (__t == 1)
 return __b;



      const _Fp __x = __a + __t * (__b - __a);
      return (__t > 1) == (__b > __a)
 ? (__b < __x ? __x : __b)
 : (__b > __x ? __x : __b);
    }

  constexpr float
  lerp(float __a, float __b, float __t) noexcept
  { return std::__lerp(__a, __b, __t); }

  constexpr double
  lerp(double __a, double __b, double __t) noexcept
  { return std::__lerp(__a, __b, __t); }

  constexpr long double
  lerp(long double __a, long double __b, long double __t) noexcept
  { return std::__lerp(__a, __b, __t); }

  template<typename _Tp, typename _Up, typename _Vp>
    constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
    lerp(_Tp __x, _Up __y, _Vp __z) noexcept
    {
      using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
      return std::__lerp<__type>(__x, __y, __z);
    }
# 3910 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 3
}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wlong-long"
#pragma GCC diagnostic ignored "-Wc++23-extensions"
# 165 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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
  };
# 209 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 295 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  };
# 318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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> { };
# 390 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 3
  template<>
    struct numeric_limits<bool>
    {
      static constexpr bool is_specialized = true;

      static constexpr bool
      min() noexcept { return false; }

      static constexpr bool
      max() noexcept { return true; }


      static constexpr bool
      lowest() noexcept { return min(); }

      static constexpr int digits = 1;
      static constexpr int digits10 = 0;

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr bool
      epsilon() noexcept { return false; }

      static constexpr bool
      round_error() noexcept { return false; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr bool
      infinity() noexcept { return false; }

      static constexpr bool
      quiet_NaN() noexcept { return false; }

      static constexpr bool
      signaling_NaN() noexcept { return false; }

      static constexpr bool
      denorm_min() noexcept { return false; }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;




      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<char>
    {
      static constexpr bool is_specialized = true;

      static constexpr char
      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }

      static constexpr char
      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }


      static constexpr char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((char)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char
      epsilon() noexcept { return 0; }

      static constexpr char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr
      char infinity() noexcept { return char(); }

      static constexpr char
      quiet_NaN() noexcept { return char(); }

      static constexpr char
      signaling_NaN() noexcept { return char(); }

      static constexpr char
      denorm_min() noexcept { return static_cast<char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<signed char>
    {
      static constexpr bool is_specialized = true;

      static constexpr signed char
      min() noexcept { return -127 - 1; }

      static constexpr signed char
      max() noexcept { return 127; }


      static constexpr signed char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr signed char
      epsilon() noexcept { return 0; }

      static constexpr signed char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr signed char
      infinity() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      quiet_NaN() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      signaling_NaN() noexcept
      { return static_cast<signed char>(0); }

      static constexpr signed char
      denorm_min() noexcept
      { return static_cast<signed char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned char>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned char
      min() noexcept { return 0; }

      static constexpr unsigned char
      max() noexcept { return 127 * 2U + 1; }


      static constexpr unsigned char
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned char
      epsilon() noexcept { return 0; }

      static constexpr unsigned char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned char
      infinity() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      quiet_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      signaling_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      denorm_min() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<wchar_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr wchar_t
      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }

      static constexpr wchar_t
      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }


      static constexpr wchar_t
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr wchar_t
      epsilon() noexcept { return 0; }

      static constexpr wchar_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr wchar_t
      infinity() noexcept { return wchar_t(); }

      static constexpr wchar_t
      quiet_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      signaling_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      denorm_min() noexcept { return wchar_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };



  template<>
    struct numeric_limits<char8_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char8_t
      min() noexcept { return (((char8_t)(-1) < 0) ? -(((char8_t)(-1) < 0) ? (((((char8_t)1 << ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char8_t)0) - 1 : (char8_t)0); }

      static constexpr char8_t
      max() noexcept { return (((char8_t)(-1) < 0) ? (((((char8_t)1 << ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char8_t)0); }

      static constexpr char8_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char8_t) * 8 - ((char8_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char8_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char8_t
      epsilon() noexcept { return 0; }

      static constexpr char8_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
 = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char8_t
      infinity() noexcept { return char8_t(); }

      static constexpr char8_t
      quiet_NaN() noexcept { return char8_t(); }

      static constexpr char8_t
      signaling_NaN() noexcept { return char8_t(); }

      static constexpr char8_t
      denorm_min() noexcept { return char8_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
 = round_toward_zero;
    };




  template<>
    struct numeric_limits<char16_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char16_t
      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }

      static constexpr char16_t
      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }

      static constexpr char16_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char16_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char16_t
      epsilon() noexcept { return 0; }

      static constexpr char16_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char16_t
      infinity() noexcept { return char16_t(); }

      static constexpr char16_t
      quiet_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      signaling_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      denorm_min() noexcept { return char16_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<char32_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char32_t
      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }

      static constexpr char32_t
      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }

      static constexpr char32_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char32_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char32_t
      epsilon() noexcept { return 0; }

      static constexpr char32_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char32_t
      infinity() noexcept { return char32_t(); }

      static constexpr char32_t
      quiet_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      signaling_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      denorm_min() noexcept { return char32_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };



  template<>
    struct numeric_limits<short>
    {
      static constexpr bool is_specialized = true;

      static constexpr short
      min() noexcept { return -32767 - 1; }

      static constexpr short
      max() noexcept { return 32767; }


      static constexpr short
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr short
      epsilon() noexcept { return 0; }

      static constexpr short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr short
      infinity() noexcept { return short(); }

      static constexpr short
      quiet_NaN() noexcept { return short(); }

      static constexpr short
      signaling_NaN() noexcept { return short(); }

      static constexpr short
      denorm_min() noexcept { return short(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned short>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned short
      min() noexcept { return 0; }

      static constexpr unsigned short
      max() noexcept { return 32767 * 2U + 1; }


      static constexpr unsigned short
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned short
      epsilon() noexcept { return 0; }

      static constexpr unsigned short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned short
      infinity() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      quiet_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      signaling_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      denorm_min() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<int>
    {
      static constexpr bool is_specialized = true;

      static constexpr int
      min() noexcept { return -2147483647 - 1; }

      static constexpr int
      max() noexcept { return 2147483647; }


      static constexpr int
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr int
      epsilon() noexcept { return 0; }

      static constexpr int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr int
      infinity() noexcept { return static_cast<int>(0); }

      static constexpr int
      quiet_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      signaling_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      denorm_min() noexcept { return static_cast<int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned int>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned int
      min() noexcept { return 0; }

      static constexpr unsigned int
      max() noexcept { return 2147483647 * 2U + 1; }


      static constexpr unsigned int
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned int
      epsilon() noexcept { return 0; }

      static constexpr unsigned int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned int
      infinity() noexcept { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      quiet_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      signaling_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      denorm_min() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long
      min() noexcept { return -9223372036854775807L - 1; }

      static constexpr long
      max() noexcept { return 9223372036854775807L; }


      static constexpr long
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long
      epsilon() noexcept { return 0; }

      static constexpr long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long
      infinity() noexcept { return static_cast<long>(0); }

      static constexpr long
      quiet_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      signaling_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      denorm_min() noexcept { return static_cast<long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long
      min() noexcept { return 0; }

      static constexpr unsigned long
      max() noexcept { return 9223372036854775807L * 2UL + 1; }


      static constexpr unsigned long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long
      infinity() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      quiet_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      signaling_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      denorm_min() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long long
      min() noexcept { return -9223372036854775807LL - 1; }

      static constexpr long long
      max() noexcept { return 9223372036854775807LL; }


      static constexpr long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long long
      epsilon() noexcept { return 0; }

      static constexpr long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long long
      infinity() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      quiet_NaN() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      signaling_NaN() noexcept
      { return static_cast<long long>(0); }

      static constexpr long long
      denorm_min() noexcept { return static_cast<long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long long
      min() noexcept { return 0; }

      static constexpr unsigned long long
      max() noexcept { return 9223372036854775807LL * 2ULL + 1; }


      static constexpr unsigned long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long long
      infinity() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      quiet_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      signaling_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      denorm_min() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };
# 1665 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 3
  __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; __extension__ template<> struct numeric_limits<unsigned __int128> { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast<unsigned __int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; };
# 1676 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 3
  template<>
    struct numeric_limits<float>
    {
      static constexpr bool is_specialized = true;

      static constexpr float
      min() noexcept { return 1.17549435e-38F; }

      static constexpr float
      max() noexcept { return 3.40282347e+38F; }


      static constexpr float
      lowest() noexcept { return -3.40282347e+38F; }


      static constexpr int digits = 24;
      static constexpr int digits10 = 6;

      static constexpr int max_digits10
  = (2 + (24) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr float
      epsilon() noexcept { return 1.19209290e-7F; }

      static constexpr float
      round_error() noexcept { return 0.5F; }

      static constexpr int min_exponent = (-125);
      static constexpr int min_exponent10 = (-37);
      static constexpr int max_exponent = 128;
      static constexpr int max_exponent10 = 38;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
       = false;

      static constexpr float
      infinity() noexcept { return __builtin_huge_valf(); }

      static constexpr float
      quiet_NaN() noexcept { return __builtin_nanf(""); }

      static constexpr float
      signaling_NaN() noexcept { return __builtin_nansf(""); }

      static constexpr float
      denorm_min() noexcept { return 1.40129846e-45F; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };






  template<>
    struct numeric_limits<double>
    {
      static constexpr bool is_specialized = true;

      static constexpr double
      min() noexcept { return 2.2250738585072014e-308; }

      static constexpr double
      max() noexcept { return 1.7976931348623157e+308; }


      static constexpr double
      lowest() noexcept { return -1.7976931348623157e+308; }


      static constexpr int digits = 53;
      static constexpr int digits10 = 15;

      static constexpr int max_digits10
  = (2 + (53) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr double
      epsilon() noexcept { return 2.2204460492503131e-16; }

      static constexpr double
      round_error() noexcept { return 0.5; }

      static constexpr int min_exponent = (-1021);
      static constexpr int min_exponent10 = (-307);
      static constexpr int max_exponent = 1024;
      static constexpr int max_exponent10 = 308;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
        = false;

      static constexpr double
      infinity() noexcept { return __builtin_huge_val(); }

      static constexpr double
      quiet_NaN() noexcept { return __builtin_nan(""); }

      static constexpr double
      signaling_NaN() noexcept { return __builtin_nans(""); }

      static constexpr double
      denorm_min() noexcept { return 4.9406564584124654e-324; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };






  template<>
    struct numeric_limits<long double>
    {
      static constexpr bool is_specialized = true;

      static constexpr long double
      min() noexcept { return 3.36210314311209350626e-4932L; }

      static constexpr long double
      max() noexcept { return 1.18973149535723176502e+4932L; }


      static constexpr long double
      lowest() noexcept { return -1.18973149535723176502e+4932L; }


      static constexpr int digits = 64;
      static constexpr int digits10 = 18;

      static constexpr int max_digits10
  = (2 + (64) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr long double
      epsilon() noexcept { return 1.08420217248550443401e-19L; }

      static constexpr long double
      round_error() noexcept { return 0.5L; }

      static constexpr int min_exponent = (-16381);
      static constexpr int min_exponent10 = (-4931);
      static constexpr int max_exponent = 16384;
      static constexpr int max_exponent10 = 4932;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
 = false;

      static constexpr long double
      infinity() noexcept { return __builtin_huge_vall(); }

      static constexpr long double
      quiet_NaN() noexcept { return __builtin_nanl(""); }

      static constexpr long double
      signaling_NaN() noexcept { return __builtin_nansl(""); }

      static constexpr long double
      denorm_min() noexcept { return 3.64519953188247460253e-4951L; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before =
      false;
      static constexpr float_round_style round_style =
            round_to_nearest;
    };
# 2094 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/limits" 3
  __extension__
  template<>
    struct numeric_limits<__float128>
    {
      static constexpr bool is_specialized = true;

      static constexpr __float128
      min() noexcept
      {


 return double(9.3132257461547852e-10) * _S_1pm16352();



      }

      static constexpr __float128
      max() noexcept
      {



 return (__float128(double(3.4028236692093843e+38))
    + double(3.7778931862957153e+22) + double(8.35584e+6))
   * _S_1p16256();



      }

      static constexpr __float128
      lowest() noexcept
      { return -max(); }

      static constexpr int digits = 113;
      static constexpr int digits10 = 33;

      static constexpr int max_digits10 = 35;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr __float128
      epsilon() noexcept
      { return double(1.9259299443872359e-34); }

      static constexpr __float128
      round_error() noexcept { return 0.5; }

      static constexpr int min_exponent = -16381;
      static constexpr int min_exponent10 = -4931;
      static constexpr int max_exponent = 16384;
      static constexpr int max_exponent10 = 4932;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;


      static constexpr bool has_signaling_NaN = true;



      static constexpr float_denorm_style has_denorm
 = denorm_present;
      static constexpr bool has_denorm_loss = false;

      static constexpr __float128
      infinity() noexcept
      { return __builtin_huge_val(); }

      static constexpr __float128
      quiet_NaN() noexcept
      { return __builtin_nan(""); }

      static constexpr __float128
      signaling_NaN() noexcept
      {



 return __builtin_bit_cast(__float128, __builtin_nansf128(""));



      }

      static constexpr __float128
      denorm_min() noexcept
      {


 return double(1.7936620343357659e-43) * _S_1pm16352();



      }

      static constexpr bool is_iec559 = has_signaling_NaN;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
 = round_to_nearest;


    private:
      static constexpr __float128
      _S_4p(__float128 __v) noexcept
      { return __v * __v * __v * __v; }

      static constexpr __float128
      _S_1pm4088() noexcept
      { return _S_4p( double(2.2250738585072014e-308)); }

      static constexpr __float128
      _S_1pm16352() noexcept
      { return _S_4p(_S_1pm4088()); }

      static constexpr __float128
      _S_1p4064() noexcept
      { return _S_4p( double(7.0222388080559215e+305)); }

      static constexpr __float128
      _S_1p16256() noexcept
      { return _S_4p(_S_1p4064()); }

    };




}








#pragma GCC diagnostic pop
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/special_function_util.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/special_function_util.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/special_function_util.h" 3
    template<typename _Tp>
    inline bool __isnan(_Tp __x)
    { return std::isnan(__x); }
# 133 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/special_function_util.h" 3
  }





}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 3
  namespace __detail
  {
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __bernoulli(int __n)
    { return __bernoulli_series<_Tp>(__n); }
# 153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __gamma(_Tp __x)
    { return std::exp(__log_gamma(__x)); }
# 356 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi(unsigned int __n, _Tp __x)
    {
      if (__x <= _Tp(0))
        std::__throw_domain_error(("Argument out of range " "in __psi"));

      else if (__n == 0)
        return __psi(__x);
      else
        {
          const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);

          const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1));



          _Tp __result = std::exp(__ln_nfact) * __hzeta;
          if (__n % 2 == 1)
            __result = -__result;
          return __result;
        }
    }
  }






}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/bessel_function.tcc" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/bessel_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 71 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/bessel_function.tcc" 3
  namespace __detail
  {
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_neumann(unsigned int __n, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __sph_neumann."));

      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == _Tp(0))
        return -std::numeric_limits<_Tp>::infinity();
      else
        {
          _Tp __j_n, __n_n, __jp_n, __np_n;
          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
          return __n_n;
        }
    }
  }






}
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/beta_function.tcc" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/beta_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/beta_function.tcc" 3
  namespace __detail
  {
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/beta_function.tcc" 3
      return __bet;
    }
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/beta_function.tcc" 3
    template<typename _Tp>
    inline _Tp
    __beta(_Tp __x, _Tp __y)
    {
      if (__isnan(__x) || __isnan(__y))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __beta_lgamma(__x, __y);
    }
  }






}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
  namespace __detail
  {
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = _Tp(5) * __min;

      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rf."));

      else if (__x + __y < __lolim || __x + __z < __lolim
            || __y + __z < __lolim)
        std::__throw_domain_error(("Argument too small in __ellint_rf"));
      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(1) / _Tp(24);
          const _Tp __c2 = _Tp(1) / _Tp(10);
          const _Tp __c3 = _Tp(3) / _Tp(44);
          const _Tp __c4 = _Tp(1) / _Tp(14);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
          _Tp __mu;
          _Tp __xndev, __yndev, __zndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + __zn) / _Tp(3);
              __xndev = 2 - (__mu + __xn) / __mu;
              __yndev = 2 - (__mu + __yn) / __mu;
              __zndev = 2 - (__mu + __zn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              if (__epsilon < __errtol)
                break;
              const _Tp __xnroot = std::sqrt(__xn);
              const _Tp __ynroot = std::sqrt(__yn);
              const _Tp __znroot = std::sqrt(__zn);
              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
                                 + __ynroot * __znroot;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
            }

          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
          const _Tp __e3 = __xndev * __yndev * __zndev;
          const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
                   + __c4 * __e3;

          return __s / std::sqrt(__mu);
        }
    }
# 153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk / _Tp(4);
      _Tp __sum = _Tp(1) + __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          __term *= (2 * __i - 1) * __kk / (2 * __i);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return __numeric_constants<_Tp>::__pi_2() * __sum;
    }
# 191 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) >= _Tp(1))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
    }
# 219 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_1(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_1."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __s = std::sin(__phi_red);
          const _Tp __c = std::cos(__phi_red);

          const _Tp __F = __s
                        * __ellint_rf(__c * __c,
                                _Tp(1) - __k * __k * __s * __s, _Tp(1));

          if (__n == 0)
            return __F;
          else
            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
        }
    }
# 266 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk;
      _Tp __sum = __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          const _Tp __i2m = 2 * __i - 1;
          const _Tp __i2 = 2 * __i;
          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term / __i2m;
        }

      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
    }
# 314 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));

      if (__x < _Tp(0) || __y < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rd."));

      else if (__x + __y < __lolim || __z < __lolim)
        std::__throw_domain_error(("Argument too small " "in __ellint_rd."));

      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(3) / _Tp(14);
          const _Tp __c2 = _Tp(1) / _Tp(6);
          const _Tp __c3 = _Tp(9) / _Tp(22);
          const _Tp __c4 = _Tp(3) / _Tp(26);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;
          _Tp __sigma = _Tp(0);
          _Tp __power4 = _Tp(1);

          _Tp __mu;
          _Tp __xndev, __yndev, __zndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
              __xndev = (__mu - __xn) / __mu;
              __yndev = (__mu - __yn) / __mu;
              __zndev = (__mu - __zn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              if (__epsilon < __errtol)
                break;
              _Tp __xnroot = std::sqrt(__xn);
              _Tp __ynroot = std::sqrt(__yn);
              _Tp __znroot = std::sqrt(__zn);
              _Tp __lambda = __xnroot * (__ynroot + __znroot)
                           + __ynroot * __znroot;
              __sigma += __power4 / (__znroot * (__zn + __lambda));
              __power4 *= __c0;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
            }

          _Tp __ea = __xndev * __yndev;
          _Tp __eb = __zndev * __zndev;
          _Tp __ec = __ea - __eb;
          _Tp __ed = __ea - _Tp(6) * __eb;
          _Tp __ef = __ed + __ec + __ec;
          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
                                   / _Tp(2));
          _Tp __s2 = __zndev
                   * (__c2 * __ef
                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea));

          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
                                        / (__mu * std::sqrt(__mu));
        }
    }
# 399 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) == 1)
        return _Tp(1);
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_2."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
        }
    }
# 433 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_2(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_2."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __E = __s
                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        - __kk * __sss
                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        / _Tp(3);

          if (__n == 0)
            return __E;
          else
            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
        }
    }
# 492 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rc(_Tp __x, _Tp __y)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = _Tp(5) * __min;

      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rc."));

      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(1) / _Tp(7);
          const _Tp __c2 = _Tp(9) / _Tp(22);
          const _Tp __c3 = _Tp(3) / _Tp(10);
          const _Tp __c4 = _Tp(3) / _Tp(8);

          _Tp __xn = __x;
          _Tp __yn = __y;

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
          _Tp __mu;
          _Tp __sn;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
              __sn = (__yn + __mu) / __mu - _Tp(2);
              if (std::abs(__sn) < __errtol)
                break;
              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
                             + __yn;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
            }

          _Tp __s = __sn * __sn
                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));

          return (_Tp(1) + __s) / std::sqrt(__mu);
        }
    }
# 561 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));

      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rj."));

      else if (__x + __y < __lolim || __x + __z < __lolim
            || __y + __z < __lolim || __p < __lolim)
        std::__throw_domain_error(("Argument too small " "in __ellint_rj"));

      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(3) / _Tp(14);
          const _Tp __c2 = _Tp(1) / _Tp(3);
          const _Tp __c3 = _Tp(3) / _Tp(22);
          const _Tp __c4 = _Tp(3) / _Tp(26);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;
          _Tp __pn = __p;
          _Tp __sigma = _Tp(0);
          _Tp __power4 = _Tp(1);

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));

          _Tp __mu;
          _Tp __xndev, __yndev, __zndev, __pndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
              __xndev = (__mu - __xn) / __mu;
              __yndev = (__mu - __yn) / __mu;
              __zndev = (__mu - __zn) / __mu;
              __pndev = (__mu - __pn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              __epsilon = std::max(__epsilon, std::abs(__pndev));
              if (__epsilon < __errtol)
                break;
              const _Tp __xnroot = std::sqrt(__xn);
              const _Tp __ynroot = std::sqrt(__yn);
              const _Tp __znroot = std::sqrt(__zn);
              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
                                 + __ynroot * __znroot;
              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
                                + __xnroot * __ynroot * __znroot;
              const _Tp __alpha2 = __alpha1 * __alpha1;
              const _Tp __beta = __pn * (__pn + __lambda)
                                      * (__pn + __lambda);
              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
              __power4 *= __c0;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
              __pn = __c0 * (__pn + __lambda);
            }

          _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev;
          _Tp __eb = __xndev * __yndev * __zndev;
          _Tp __ec = __pndev * __pndev;
          _Tp __e2 = __ea - _Tp(3) * __ec;
          _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec);
          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
                            - _Tp(3) * __c4 * __e3 / _Tp(2));
          _Tp __s2 = __eb * (__c2 / _Tp(2)
                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
          _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3)
                   - __c2 * __pndev * __ec;

          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
                                             / (__mu * std::sqrt(__mu));
        }
    }
# 661 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_3(_Tp __k, _Tp __nu)
    {

      if (__isnan(__k) || __isnan(__nu))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__nu == _Tp(1))
        return std::numeric_limits<_Tp>::infinity();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_3."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               + __nu
               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu)
               / _Tp(3);
        }
    }
# 701 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_3."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __Pi = __s
                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                         + __nu * __sss
                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
                                       _Tp(1) - __nu * __ss) / _Tp(3);

          if (__n == 0)
            return __Pi;
          else
            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
        }
    }
  }





}
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/exp_integral.tcc" 1 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/exp_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/exp_integral.tcc" 3
  namespace __detail
  {
    template<typename _Tp> _Tp __expint_E1(_Tp);
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    inline _Tp
    __expint(_Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __expint_Ei(__x);
    }
  }





}
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/hypergeometric.tcc" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/hypergeometric.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/hypergeometric.tcc" 3
  namespace __detail
  {
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {

      const _Tp __a_nint = ::std::nearbyint(__a);
      const _Tp __b_nint = ::std::nearbyint(__b);
      const _Tp __c_nint = ::std::nearbyint(__c);





      const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
      if (std::abs(__x) >= _Tp(1))
        std::__throw_domain_error(("Argument outside unit circle " "in __hyperg."));

      else if (__isnan(__a) || __isnan(__b)
            || __isnan(__c) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__c_nint == __c && __c_nint <= _Tp(0))
        return std::numeric_limits<_Tp>::infinity();
      else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
        return std::pow(_Tp(1) - __x, __c - __a - __b);
      else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
            && __x >= _Tp(0) && __x < _Tp(0.995L))
        return __hyperg_series(__a, __b, __c, __x);
      else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
        {


          if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
            return __hyperg_series(__a_nint, __b, __c, __x);
          else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
            return __hyperg_series(__a, __b_nint, __c, __x);
          else if (__x < -_Tp(0.25L))
            return __hyperg_luke(__a, __b, __c, __x);
          else if (__x < _Tp(0.5L))
            return __hyperg_series(__a, __b, __c, __x);
          else
            if (std::abs(__c) > _Tp(10))
              return __hyperg_series(__a, __b, __c, __x);
            else
              return __hyperg_reflect(__a, __b, __c, __x);
        }
      else
        return __hyperg_luke(__a, __b, __c, __x);
    }
  }






}
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/legendre_function.tcc" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/legendre_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/legendre_function.tcc" 3
  namespace __detail
  {
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/legendre_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      if (__isnan(__theta))
        return std::numeric_limits<_Tp>::quiet_NaN();

      const _Tp __x = std::cos(__theta);

      if (__m > __l)
        return _Tp(0);
      else if (__m == 0)
        {
          _Tp __P = __poly_legendre_p(__l, __x);
          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          __P *= __fact;
          return __P;
        }
      else if (__x == _Tp(1) || __x == -_Tp(1))
        {

          return _Tp(0);
        }
      else
        {





          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));

          const _Tp __lncirc = ::std::log1p(-__x * __x);





          const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L)))
                             - ::std::lgamma(_Tp(__m));




          const _Tp __lnpre_val =
                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
          const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
                         / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;

          if (__l == __m)
            return __y_mm;
          else if (__l == __m + 1)
            return __y_mp1m;
          else
            {
              _Tp __y_lm = _Tp(0);


              for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll)
                {
                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
                                                       * _Tp(2 * __ll - 1));
                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
                                                                / _Tp(2 * __ll - 3));
                  __y_lm = (__x * __y_mp1m * __fact1
                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
                  __y_mm = __y_mp1m;
                  __y_mp1m = __y_lm;
                }

              return __y_lm;
            }
        }
    }
  }






}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/modified_bessel_func.tcc" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/modified_bessel_func.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/modified_bessel_func.tcc" 3
  namespace __detail
  {
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
    {
      const _Tp __absx = std::abs(__x);
      const _Tp __rootx = std::sqrt(__absx);
      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
      const _Tp _S_inf = std::numeric_limits<_Tp>::infinity();

      if (__isnan(__x))
        __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN();
      else if (__z == _S_inf)
        {
   __Aip = __Ai = _Tp(0);
   __Bip = __Bi = _S_inf;
 }
      else if (__z == -_S_inf)
 __Bip = __Aip = __Bi = __Ai = _Tp(0);
      else if (__x > _Tp(0))
        {
          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;

          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          __Ai = __rootx * __K_nu
               / (__numeric_constants<_Tp>::__sqrt3()
                * __numeric_constants<_Tp>::__pi());
          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());

          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          __Aip = -__x * __K_nu
                / (__numeric_constants<_Tp>::__sqrt3()
                 * __numeric_constants<_Tp>::__pi());
          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
                      + _Tp(2) * __I_nu
                      / __numeric_constants<_Tp>::__sqrt3());
        }
      else if (__x < _Tp(0))
        {
          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;

          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          __Ai = __rootx * (__J_nu
                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
          __Bi = -__rootx * (__N_nu
                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);

          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
                          + __J_nu) / _Tp(2);
          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
                          - __N_nu) / _Tp(2);
        }
      else
        {



          __Ai = _Tp(0.35502805388781723926L);
          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();




          __Aip = -_Tp(0.25881940379280679840L);
          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
        }

      return;
    }
  }





}
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_hermite.tcc" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_hermite.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_hermite.tcc" 3
  namespace __detail
  {
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_hermite.tcc" 3
    template<typename _Tp>
    inline _Tp
    __poly_hermite(unsigned int __n, _Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __poly_hermite_recursion(__n, __x);
    }
  }





}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_laguerre.tcc" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_laguerre.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_laguerre.tcc" 3
  namespace __detail
  {
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/poly_laguerre.tcc" 3
    template<typename _Tp>
    inline _Tp
    __laguerre(unsigned int __n, _Tp __x)
    { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
  }






}
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/riemann_zeta.tcc" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/riemann_zeta.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/riemann_zeta.tcc" 3
  namespace __detail
  {
# 78 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    inline _Tp
    __hurwitz_zeta(_Tp __a, _Tp __s)
    { return __hurwitz_zeta_glob(__a, __s); }
  }






}
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 203 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }







  inline long double
  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
# 248 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
    }
# 264 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }






  inline long double
  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
# 294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
    }
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  betaf(float __a, float __b)
  { return __detail::__beta<float>(__a, __b); }







  inline long double
  betal(long double __a, long double __b)
  { return __detail::__beta<long double>(__a, __b); }
# 339 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tpa, typename _Tpb>
    inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
    beta(_Tpa __a, _Tpb __b)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
      return __detail::__beta<__type>(__a, __b);
    }
# 355 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  comp_ellint_1f(float __k)
  { return __detail::__comp_ellint_1<float>(__k); }







  inline long double
  comp_ellint_1l(long double __k)
  { return __detail::__comp_ellint_1<long double>(__k); }
# 387 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_1(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_1<__type>(__k);
    }
# 403 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  comp_ellint_2f(float __k)
  { return __detail::__comp_ellint_2<float>(__k); }







  inline long double
  comp_ellint_2l(long double __k)
  { return __detail::__comp_ellint_2<long double>(__k); }
# 434 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_2(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_2<__type>(__k);
    }
# 450 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  comp_ellint_3f(float __k, float __nu)
  { return __detail::__comp_ellint_3<float>(__k, __nu); }







  inline long double
  comp_ellint_3l(long double __k, long double __nu)
  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
# 485 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
    comp_ellint_3(_Tp __k, _Tpn __nu)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
      return __detail::__comp_ellint_3<__type>(__k, __nu);
    }
# 501 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  cyl_bessel_if(float __nu, float __x)
  { return __detail::__cyl_bessel_i<float>(__nu, __x); }







  inline long double
  cyl_bessel_il(long double __nu, long double __x)
  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
# 531 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_i(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_i<__type>(__nu, __x);
    }
# 547 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  cyl_bessel_jf(float __nu, float __x)
  { return __detail::__cyl_bessel_j<float>(__nu, __x); }







  inline long double
  cyl_bessel_jl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
# 577 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_j(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_j<__type>(__nu, __x);
    }
# 593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  cyl_bessel_kf(float __nu, float __x)
  { return __detail::__cyl_bessel_k<float>(__nu, __x); }







  inline long double
  cyl_bessel_kl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
# 629 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_k(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_k<__type>(__nu, __x);
    }
# 645 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  cyl_neumannf(float __nu, float __x)
  { return __detail::__cyl_neumann_n<float>(__nu, __x); }







  inline long double
  cyl_neumannl(long double __nu, long double __x)
  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
# 677 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_neumann(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_neumann_n<__type>(__nu, __x);
    }
# 693 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  ellint_1f(float __k, float __phi)
  { return __detail::__ellint_1<float>(__k, __phi); }







  inline long double
  ellint_1l(long double __k, long double __phi)
  { return __detail::__ellint_1<long double>(__k, __phi); }
# 725 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_1(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_1<__type>(__k, __phi);
    }
# 741 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  ellint_2f(float __k, float __phi)
  { return __detail::__ellint_2<float>(__k, __phi); }







  inline long double
  ellint_2l(long double __k, long double __phi)
  { return __detail::__ellint_2<long double>(__k, __phi); }
# 773 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_2(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_2<__type>(__k, __phi);
    }
# 789 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  ellint_3f(float __k, float __nu, float __phi)
  { return __detail::__ellint_3<float>(__k, __nu, __phi); }







  inline long double
  ellint_3l(long double __k, long double __nu, long double __phi)
  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
# 826 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn, typename _Tpp>
    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
      return __detail::__ellint_3<__type>(__k, __nu, __phi);
    }
# 841 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  expintf(float __x)
  { return __detail::__expint<float>(__x); }







  inline long double
  expintl(long double __x)
  { return __detail::__expint<long double>(__x); }
# 866 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    expint(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__expint<__type>(__x);
    }
# 882 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  hermitef(unsigned int __n, float __x)
  { return __detail::__poly_hermite<float>(__n, __x); }







  inline long double
  hermitel(unsigned int __n, long double __x)
  { return __detail::__poly_hermite<long double>(__n, __x); }
# 914 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    hermite(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_hermite<__type>(__n, __x);
    }
# 930 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  laguerref(unsigned int __n, float __x)
  { return __detail::__laguerre<float>(__n, __x); }







  inline long double
  laguerrel(unsigned int __n, long double __x)
  { return __detail::__laguerre<long double>(__n, __x); }
# 958 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    laguerre(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__laguerre<__type>(__n, __x);
    }
# 974 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  legendref(unsigned int __l, float __x)
  { return __detail::__poly_legendre_p<float>(__l, __x); }







  inline long double
  legendrel(unsigned int __l, long double __x)
  { return __detail::__poly_legendre_p<long double>(__l, __x); }
# 1003 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    legendre(unsigned int __l, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_legendre_p<__type>(__l, __x);
    }
# 1019 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  riemann_zetaf(float __s)
  { return __detail::__riemann_zeta<float>(__s); }







  inline long double
  riemann_zetal(long double __s)
  { return __detail::__riemann_zeta<long double>(__s); }
# 1054 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    riemann_zeta(_Tp __s)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__riemann_zeta<__type>(__s);
    }
# 1070 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  sph_besself(unsigned int __n, float __x)
  { return __detail::__sph_bessel<float>(__n, __x); }







  inline long double
  sph_bessell(unsigned int __n, long double __x)
  { return __detail::__sph_bessel<long double>(__n, __x); }
# 1098 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_bessel(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_bessel<__type>(__n, __x);
    }
# 1114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
# 1125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline long double
  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
# 1145 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_legendre<__type>(__l, __m, __theta);
    }
# 1161 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/specfun.h" 3
  inline float
  sph_neumannf(unsigned int __n, float __x)
  { return __detail::__sph_neumann<float>(__n, __x); }







  inline long double
  sph_neumannl(unsigned int __n, long double __x)
  { return __detail::__sph_neumann<long double>(__n, __x); }
# 1189 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }




}
# 3914 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cmath" 2 3


}
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.icc" 2 3

namespace CLHEP {







inline double & Hep3Vector::operator[] (int i) { return data[i]; }
inline double Hep3Vector::operator[] (int i) const { return data[i]; }

inline double Hep3Vector::x() const { return (*this)[X]; }
inline double Hep3Vector::y() const { return (*this)[Y]; }
inline double Hep3Vector::z() const { return (*this)[Z]; }

inline double Hep3Vector::getX() const { return (*this)[X]; }
inline double Hep3Vector::getY() const { return (*this)[Y]; }
inline double Hep3Vector::getZ() const { return (*this)[Z]; }

inline void Hep3Vector::setX(double x) { (*this)[X] = x; }
inline void Hep3Vector::setY(double y) { (*this)[Y] = y; }
inline void Hep3Vector::setZ(double z) { (*this)[Z] = z; }

inline void Hep3Vector::set(double x, double y, double z) {
  (*this)[X] = x;
  (*this)[Y] = y;
  (*this)[Z] = z;
}

inline double Hep3Vector::operator () (int i) const {
  return data[i];
}

inline double & Hep3Vector::operator () (int i) {
  return data[i];
}





inline Hep3Vector operator + (const Hep3Vector & a, const Hep3Vector & b) {
  return Hep3Vector(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
}

inline Hep3Vector operator - (const Hep3Vector & a, const Hep3Vector & b) {
  return Hep3Vector(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
}

inline Hep3Vector operator * (const Hep3Vector & p, double a) {
  return Hep3Vector(a*p.x(), a*p.y(), a*p.z());
}

inline Hep3Vector operator * (double a, const Hep3Vector & p) {
  return Hep3Vector(a*p.x(), a*p.y(), a*p.z());
}

inline double operator * (const Hep3Vector & a, const Hep3Vector & b) {
  return a.dot(b);
}





inline void Hep3Vector::setRThetaPhi
    ( double r1, double theta1, double phi1 ) {
  setSpherical (r1, theta1, phi1);
}

inline void Hep3Vector::setREtaPhi
    ( double r1, double eta1, double phi1 ) {
  setSpherical (r1, 2*std::atan(std::exp(-eta1)), phi1);
}

inline void Hep3Vector::setRhoPhiZ
    ( double rho1, double phi1, double z1) {
  setCylindrical (rho1, phi1, z1);
}





inline Hep3Vector::Hep3Vector()
  : data{0.0, 0.0, 0.0} {}
inline Hep3Vector::Hep3Vector(double x)
  : data{ x , 0.0, 0.0} {}
inline Hep3Vector::Hep3Vector(double x, double y)
  : data{ x , y , 0.0} {}
inline Hep3Vector::Hep3Vector(double x, double y, double z)
  : data{ x , y , z } {}

inline Hep3Vector::Hep3Vector(const Hep3Vector & p)
  : data{p.x(), p.y(), p.z()} {}

inline Hep3Vector::~Hep3Vector() {}

inline Hep3Vector & Hep3Vector::operator = (const Hep3Vector & p) {
  set(p.x(), p.y(), p.z());
  return *this;
}







inline double Hep3Vector::mag2() const { return x()*x() + y()*y() + z()*z(); }
inline double Hep3Vector::mag() const { return std::sqrt(mag2()); }
inline double Hep3Vector::r() const { return mag(); }

inline double Hep3Vector::theta() const {
  return x() == 0.0 && y() == 0.0 && z() == 0.0 ? 0.0 : std::atan2(perp(),z());
}
inline double Hep3Vector::phi() const {
  return x() == 0.0 && y() == 0.0 ? 0.0 : std::atan2(y(),x());
}

inline double Hep3Vector::getR() const { return mag(); }
inline double Hep3Vector::getTheta() const { return theta(); }
inline double Hep3Vector::getPhi() const { return phi(); }
inline double Hep3Vector::angle() const { return theta(); }

inline double Hep3Vector::cosTheta() const {
  double ptot = mag();
  return ptot == 0.0 ? 1.0 : z()/ptot;
}

inline double Hep3Vector::cos2Theta() const {
  double ptot2 = mag2();
  return ptot2 == 0.0 ? 1.0 : z()*z()/ptot2;
}

inline void Hep3Vector::setR(double r1) { setMag(r1); }

inline void Hep3Vector::setTheta(double th) {
  double ma = mag();
  double ph = phi();
  setX(ma*std::sin(th)*std::cos(ph));
  setY(ma*std::sin(th)*std::sin(ph));
  setZ(ma*std::cos(th));
}

inline void Hep3Vector::setPhi(double ph) {
  double xy = perp();
  setX(xy*std::cos(ph));
  setY(xy*std::sin(ph));
}



inline double Hep3Vector::perp2() const { return x()*x() + y()*y(); }
inline double Hep3Vector::perp() const { return std::sqrt(perp2()); }
inline double Hep3Vector::rho() const { return perp(); }
inline double Hep3Vector::eta() const { return pseudoRapidity();}

inline double Hep3Vector::getRho() const { return perp(); }
inline double Hep3Vector::getEta() const { return pseudoRapidity();}

inline void Hep3Vector::setPerp(double r1) {
  double p = perp();
  if (p != 0.0) {
    (*this)[X] *= r1/p;
    (*this)[Y] *= r1/p;
  }
}
inline void Hep3Vector::setRho(double rho1) { setPerp (rho1); }





inline bool Hep3Vector::operator == (const Hep3Vector& v) const {
  return (v.x()==x() && v.y()==y() && v.z()==z()) ? true : false;
}

inline bool Hep3Vector::operator != (const Hep3Vector& v) const {
  return (v.x()!=x() || v.y()!=y() || v.z()!=z()) ? true : false;
}

inline double Hep3Vector::getTolerance () {
  return tolerance;
}





inline Hep3Vector& Hep3Vector::operator += (const Hep3Vector & p) {
  (*this)[X] += p.x();
  (*this)[Y] += p.y();
  (*this)[Z] += p.z();
  return *this;
}

inline Hep3Vector& Hep3Vector::operator -= (const Hep3Vector & p) {
  (*this)[X] -= p.x();
  (*this)[Y] -= p.y();
  (*this)[Z] -= p.z();
  return *this;
}

inline Hep3Vector Hep3Vector::operator - () const {
  return Hep3Vector(-x(), -y(), -z());
}

inline Hep3Vector& Hep3Vector::operator *= (double a) {
  (*this)[X] *= a;
  (*this)[Y] *= a;
  (*this)[Z] *= a;
  return *this;
}





inline double Hep3Vector::diff2(const Hep3Vector & p) const {
  return (*this-p).mag2();
}

inline double Hep3Vector::dot(const Hep3Vector & p) const {
  return x()*p.x() + y()*p.y() + z()*p.z();
}

inline Hep3Vector Hep3Vector::cross(const Hep3Vector & p) const {
  return Hep3Vector(y()*p.z()-p.y()*z(), z()*p.x()-p.z()*x(), x()*p.y()-p.x()*y());
}

inline double Hep3Vector::perp2(const Hep3Vector & p) const {
  double tot = p.mag2();
  double ss = dot(p);
  return tot > 0.0 ? mag2()-ss*ss/tot : mag2();
}

inline double Hep3Vector::perp(const Hep3Vector & p) const {
  return std::sqrt(perp2(p));
}

inline Hep3Vector Hep3Vector::perpPart () const {
  return Hep3Vector (x(), y(), 0);
}
inline Hep3Vector Hep3Vector::project () const {
  return Hep3Vector (0, 0, z());
}

inline Hep3Vector Hep3Vector::perpPart (const Hep3Vector & v2) const {
  return ( *this - project(v2) );
}

inline double Hep3Vector::angle(const Hep3Vector & q) const {
  return std::acos(cosTheta(q));
}

inline double Hep3Vector::theta(const Hep3Vector & q) const {
  return angle(q);
}

inline double Hep3Vector::azimAngle(const Hep3Vector & v2) const {
  return deltaPhi(v2);
}





inline Hep3Vector Hep3Vector::unit() const {
  double tot = mag2();
  Hep3Vector p(x(),y(),z());
  return tot > 0.0 ? p *= (1.0/std::sqrt(tot)) : p;
}

inline Hep3Vector Hep3Vector::orthogonal() const {
  double xx = x() < 0.0 ? -x() : x();
  double yy = y() < 0.0 ? -y() : y();
  double zz = z() < 0.0 ? -z() : z();
  if (xx < yy) {
    return xx < zz ? Hep3Vector(0,z(),-y()) : Hep3Vector(y(),-x(),0);
  }else{
    return yy < zz ? Hep3Vector(-z(),0,x()) : Hep3Vector(y(),-x(),0);
  }
}

}
# 443 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ThreeVector.h" 2 3
# 125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 2 3

namespace HepGeom {

  template<class T> class Point3D;
  template<class T> class Vector3D;
  template<class T> class Normal3D;

  class Translate3D;
  class Rotate3D;
  class Scale3D;
# 172 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class Transform3D {
  protected:
    double xx_, xy_, xz_, dx_,
           yx_, yy_, yz_, dy_,
           zx_, zy_, zz_, dz_;


    Transform3D(double XX, double XY, double XZ, double DX,
  double YX, double YY, double YZ, double DY,
  double ZX, double ZY, double ZZ, double DZ)
      : xx_(XX), xy_(XY), xz_(XZ), dx_(DX),
 yx_(YX), yy_(YY), yz_(YZ), dy_(DY),
 zx_(ZX), zy_(ZY), zz_(ZZ), dz_(DZ) {}


    void setTransform(double XX, double XY, double XZ, double DX,
        double YX, double YY, double YZ, double DY,
        double ZX, double ZY, double ZZ, double DZ) {
      xx_ = XX; xy_ = XY; xz_ = XZ; dx_ = DX;
      yx_ = YX; yy_ = YY; yz_ = YZ; dy_ = DY;
      zx_ = ZX; zy_ = ZY; zz_ = ZZ; dz_ = DZ;
    }

  public:


    static const Transform3D Identity;


    class Transform3D_row {
    public:
      inline Transform3D_row(const Transform3D &, int);
      inline double operator [] (int) const;
    private:
      const Transform3D & rr;
      int ii;
    };



    Transform3D()
      : xx_(1), xy_(0), xz_(0), dx_(0),
 yx_(0), yy_(1), yz_(0), dy_(0),
 zx_(0), zy_(0), zz_(1), dz_(0) {}



    inline Transform3D(const CLHEP::HepRotation & mt, const CLHEP::Hep3Vector & v);



    Transform3D(const Point3D<double> & fr0,
  const Point3D<double> & fr1,
  const Point3D<double> & fr2,
  const Point3D<double> & to0,
  const Point3D<double> & to1,
  const Point3D<double> & to2);



    Transform3D(const Transform3D & mt) = default;



    Transform3D(Transform3D && mt) = default;



    ~Transform3D() = default;



    Transform3D & operator=(const Transform3D & mt) = default;



    Transform3D & operator=(Transform3D && mt) = default;



    inline const Transform3D_row operator [] (int) const;


    double operator () (int, int) const;



    double xx() const { return xx_; }


    double xy() const { return xy_; }


    double xz() const { return xz_; }


    double yx() const { return yx_; }


    double yy() const { return yy_; }


    double yz() const { return yz_; }


    double zx() const { return zx_; }


    double zy() const { return zy_; }


    double zz() const { return zz_; }


    double dx() const { return dx_; }


    double dy() const { return dy_; }


    double dz() const { return dz_; }



    void setIdentity() {
      xy_= xz_= dx_= yx_= yz_= dy_= zx_= zy_= dz_= 0; xx_= yy_= zz_= 1;
    }



    Transform3D inverse() const;



    Transform3D operator*(const Transform3D & b) const;
# 323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
    void getDecomposition(Scale3D & scale,
     Rotate3D & rotation,
     Translate3D & translation) const;





    bool isNear(const Transform3D & t, double tolerance = 2.2E-14 ) const;





    inline CLHEP::HepRotation getRotation() const;





    inline CLHEP::Hep3Vector getTranslation() const;



    bool operator == (const Transform3D & transform) const;



    bool operator != (const Transform3D & transform) const {
      return ! operator==(transform);
    }
  };
# 372 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class Rotate3D : public Transform3D {
  public:


    Rotate3D() : Transform3D() {}



    inline Rotate3D(const CLHEP::HepRotation &mt);







    Rotate3D(double a,
      const Point3D<double> & p1,
      const Point3D<double> & p2);






    inline Rotate3D(double a, const Vector3D<double> & v);
# 407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
    inline Rotate3D(const Point3D<double> & fr1,
      const Point3D<double> & fr2,
      const Point3D<double> & to1,
      const Point3D<double> & to2);
  };
# 427 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class RotateX3D : public Rotate3D {
  public:


    RotateX3D() : Rotate3D() {}



    RotateX3D(double a) {
      double cosa = std::cos(a), sina = std::sin(a);
      setTransform(1,0,0,0, 0,cosa,-sina,0, 0,sina,cosa,0);
    }
  };
# 455 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class RotateY3D : public Rotate3D {
  public:


    RotateY3D() : Rotate3D() {}



    RotateY3D(double a) {
      double cosa = std::cos(a), sina = std::sin(a);
      setTransform(cosa,0,sina,0, 0,1,0,0, -sina,0,cosa,0);
    }
  };
# 483 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class RotateZ3D : public Rotate3D {
  public:


    RotateZ3D() : Rotate3D() {}



    RotateZ3D(double a) {
      double cosa = std::cos(a), sina = std::sin(a);
      setTransform(cosa,-sina,0,0, sina,cosa,0,0, 0,0,1,0);
    }
  };
# 513 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class Translate3D : public Transform3D {
  public:


    Translate3D() : Transform3D() {}



    inline Translate3D(const CLHEP::Hep3Vector &v);



    Translate3D(double x, double y, double z)
      : Transform3D(1,0,0,x, 0,1,0,y, 0,0,1,z) {}
  };
# 543 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class TranslateX3D : public Translate3D {
  public:


    TranslateX3D() : Translate3D() {}



    TranslateX3D(double x) : Translate3D(x, 0, 0) {}
  };
# 568 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class TranslateY3D : public Translate3D {
  public:


    TranslateY3D() : Translate3D() {}



    TranslateY3D(double y) : Translate3D(0, y, 0) {}
  };
# 593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class TranslateZ3D : public Translate3D {
  public:


    TranslateZ3D() : Translate3D() {}



    TranslateZ3D(double z) : Translate3D(0, 0, z) {}
  };
# 620 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class Reflect3D : public Transform3D {
  protected:
    Reflect3D(double XX, double XY, double XZ, double DX,
              double YX, double YY, double YZ, double DY,
              double ZX, double ZY, double ZZ, double DZ)
      : Transform3D(XX,XY,XZ,DX, YX,YY,YZ,DY, ZX,ZY,ZZ,DZ) {}

  public:


    Reflect3D() : Transform3D() {}





    Reflect3D(double a, double b, double c, double d);



    inline Reflect3D(const Normal3D<double> & normal,
                     const Point3D<double> & point);
  };
# 658 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ReflectX3D : public Reflect3D {
  public:


    ReflectX3D(double x=0) : Reflect3D(-1,0,0,x+x, 0,1,0,0, 0,0,1,0) {}
  };
# 679 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ReflectY3D : public Reflect3D {
  public:


    ReflectY3D(double y=0) : Reflect3D(1,0,0,0, 0,-1,0,y+y, 0,0,1,0) {}
  };
# 700 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ReflectZ3D : public Reflect3D {
  public:


    ReflectZ3D(double z=0) : Reflect3D(1,0,0,0, 0,1,0,0, 0,0,-1,z+z) {}
  };
# 723 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class Scale3D : public Transform3D {
  public:


    Scale3D() : Transform3D() {}




    Scale3D(double x, double y, double z)
      : Transform3D(x,0,0,0, 0,y,0,0, 0,0,z,0) {}



    Scale3D(double sc)
      : Transform3D(sc,0,0,0, 0,sc,0,0, 0,0,sc,0) {}
  };
# 755 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ScaleX3D : public Scale3D {
  public:


    ScaleX3D() : Scale3D() {}



    ScaleX3D(double x) : Scale3D(x, 1, 1) {}
  };
# 780 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ScaleY3D : public Scale3D {
  public:


    ScaleY3D() : Scale3D() {}



    ScaleY3D(double y) : Scale3D(1, y, 1) {}
  };
# 805 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
  class ScaleZ3D : public Scale3D {
  public:


    ScaleZ3D() : Scale3D() {}


    ScaleZ3D(double z) : Scale3D(1, 1, z) {}
  };
}
# 837 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.icc" 1 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 1 3
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.h" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.h" 3
namespace CLHEP {


class HepLorentzVector;
class HepLorentzRotation;
class HepRotation;
class HepAxisAngle;
class HepEulerAngles;
class Tcomponent;
HepLorentzVector rotationXOf( const HepLorentzVector & vec, double delta );
HepLorentzVector rotationYOf( const HepLorentzVector & vec, double delta );
HepLorentzVector rotationZOf( const HepLorentzVector & vec, double delta );
HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const Hep3Vector & axis, double delta );
HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const HepAxisAngle & ax );
HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const HepEulerAngles & e1 );
HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, double phi,
                                    double theta,
                                    double psi );
inline
HepLorentzVector boostXOf( const HepLorentzVector & vec, double beta );
inline
HepLorentzVector boostYOf( const HepLorentzVector & vec, double beta );
inline
HepLorentzVector boostZOf( const HepLorentzVector & vec, double beta );
inline HepLorentzVector boostOf
    ( const HepLorentzVector & vec, const Hep3Vector & betaVector );
inline HepLorentzVector boostOf
    ( const HepLorentzVector & vec, const Hep3Vector & axis, double beta );

enum ZMpvMetric_t { TimePositive, TimeNegative };






class HepLorentzVector {

public:

  enum { X=0, Y=1, Z=2, T=3, NUM_COORDINATES=4, SIZE=NUM_COORDINATES };



  inline HepLorentzVector(double x, double y,
     double z, double t);


  inline HepLorentzVector(double x, double y, double z);


  explicit HepLorentzVector(double t);


  inline HepLorentzVector();


  inline HepLorentzVector(const Hep3Vector & p, double e);
  inline HepLorentzVector(double e, const Hep3Vector & p);


  inline HepLorentzVector(const HepLorentzVector &);
  inline HepLorentzVector(HepLorentzVector &&) = default;


  inline ~HepLorentzVector();


  inline operator const Hep3Vector & () const;
  inline operator Hep3Vector & ();


  inline double x() const;
  inline double y() const;
  inline double z() const;
  inline double t() const;


  inline void setX(double);
  inline void setY(double);
  inline void setZ(double);
  inline void setT(double);


  inline double px() const;
  inline double py() const;
  inline double pz() const;
  inline double e() const;


  inline void setPx(double);
  inline void setPy(double);
  inline void setPz(double);
  inline void setE(double);


  inline Hep3Vector vect() const;


  inline void setVect(const Hep3Vector &);


  inline double theta() const;
  inline double cosTheta() const;
  inline double phi() const;
  inline double rho() const;


  inline void setTheta(double);
  inline void setPhi(double);
  inline void setRho(double);


  double operator () (int) const;
  inline double operator [] (int) const;


  double & operator () (int);
  inline double & operator [] (int);


  inline HepLorentzVector & operator = (const HepLorentzVector &);
  inline HepLorentzVector & operator = (HepLorentzVector &&) = default;


  inline HepLorentzVector operator + (const HepLorentzVector &) const;
  inline HepLorentzVector & operator += (const HepLorentzVector &);


  inline HepLorentzVector operator - (const HepLorentzVector &) const;
  inline HepLorentzVector & operator -= (const HepLorentzVector &);


  inline HepLorentzVector operator - () const;


  inline HepLorentzVector & operator *= (double);
         HepLorentzVector & operator /= (double);


  inline bool operator == (const HepLorentzVector &) const;
  inline bool operator != (const HepLorentzVector &) const;


  inline double perp2() const;


  inline double perp() const;


  inline void setPerp(double);


  inline double perp2(const Hep3Vector &) const;


  inline double perp(const Hep3Vector &) const;


  inline double angle(const Hep3Vector &) const;


  inline double mag2() const;



  inline double m2() const;


  inline double mag() const;
  inline double m() const;


  inline double mt2() const;


  inline double mt() const;


  inline double et2() const;


  inline double et() const;


  inline double dot(const HepLorentzVector &) const;
  inline double operator * (const HepLorentzVector &) const;


  inline double invariantMass2( const HepLorentzVector & w ) const;


  double invariantMass ( const HepLorentzVector & w ) const;


  inline void setVectMag(const Hep3Vector & spatial, double magnitude);
  inline void setVectM(const Hep3Vector & spatial, double mass);


  inline double plus() const;
  inline double minus() const;


  Hep3Vector boostVector() const;



  HepLorentzVector & boost(double, double, double);
  inline HepLorentzVector & boost(const Hep3Vector &);


  HepLorentzVector & boostX( double beta );
  HepLorentzVector & boostY( double beta );
  HepLorentzVector & boostZ( double beta );


  double rapidity() const;


  inline double pseudoRapidity() const;


  inline bool isTimelike() const;


  inline bool isSpacelike() const;


  inline bool isLightlike(double epsilon=tolerance) const;


  HepLorentzVector & rotateX(double);


  HepLorentzVector & rotateY(double);


  HepLorentzVector & rotateZ(double);


  HepLorentzVector & rotateUz(const Hep3Vector &);


  HepLorentzVector & rotate(double, const Hep3Vector &);


  inline HepLorentzVector & operator *= (const HepRotation &);
  inline HepLorentzVector & transform(const HepRotation &);


  HepLorentzVector & operator *= (const HepLorentzRotation &);
  HepLorentzVector & transform(const HepLorentzRotation &);
# 305 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.h" 3
  static ZMpvMetric_t setMetric( ZMpvMetric_t a1 );
  static ZMpvMetric_t getMetric();



  inline void set (double x, double y, double z, double t);
  inline void set (double x, double y, double z, Tcomponent t);
  inline HepLorentzVector(double x, double y, double z, Tcomponent t);


  inline void set (Tcomponent t, double x, double y, double z);
  inline HepLorentzVector(Tcomponent t, double x, double y, double z);


  inline void set ( double t );

  inline void set ( Tcomponent t );
  inline explicit HepLorentzVector( Tcomponent t );


  inline void set ( const Hep3Vector & v );
  inline explicit HepLorentzVector( const Hep3Vector & v );


  inline HepLorentzVector & operator=( const Hep3Vector & v );


  inline void set ( const Hep3Vector & v, double t );
  inline void set ( double t, const Hep3Vector & v );




  inline double getX() const;
  inline double getY() const;
  inline double getZ() const;
  inline double getT() const;


  inline Hep3Vector v() const;
  inline Hep3Vector getV() const;


  inline void setV(const Hep3Vector &);




  inline void setV( double x, double y, double z );

  inline void setRThetaPhi( double r, double theta, double phi);
  inline void setREtaPhi( double r, double eta, double phi);
  inline void setRhoPhiZ( double rho, double phi, double z );



  int compare( const HepLorentzVector & w ) const;

  bool operator >( const HepLorentzVector & w ) const;
  bool operator <( const HepLorentzVector & w ) const;
  bool operator>=( const HepLorentzVector & w ) const;
  bool operator<=( const HepLorentzVector & w ) const;

  bool isNear ( const HepLorentzVector & w,
     double epsilon=tolerance ) const;
  double howNear( const HepLorentzVector & w ) const;


  bool isNearCM ( const HepLorentzVector & w,
     double epsilon=tolerance ) const;
  double howNearCM( const HepLorentzVector & w ) const;







  bool isParallel( const HepLorentzVector & w,
     double epsilon=tolerance ) const;

  double howParallel (const HepLorentzVector & w) const;

  static double getTolerance();
  static double setTolerance( double tol );



  double deltaR(const HepLorentzVector & v) const;




         double howLightlike() const;


  inline double euclideanNorm2() const;


  inline double euclideanNorm() const;







  inline double restMass2() const;
  inline double invariantMass2() const;


  inline double restMass() const;
  inline double invariantMass() const;





  HepLorentzVector rest4Vector() const;





  double beta() const;


  double gamma() const;


  inline double eta() const;


  inline double eta(const Hep3Vector & ref) const;


  double rapidity(const Hep3Vector & ref) const;


  double coLinearRapidity() const;


  Hep3Vector findBoostToCM() const;




  Hep3Vector findBoostToCM( const HepLorentzVector & w ) const;




  inline double et2(const Hep3Vector &) const;


  inline double et(const Hep3Vector &) const;




  inline double diff2( const HepLorentzVector & w ) const;


  inline double delta2Euclidean ( const HepLorentzVector & w ) const;




  double plus( const Hep3Vector & ref ) const;


  double minus( const Hep3Vector & ref ) const;




  HepLorentzVector & rotate ( const Hep3Vector & axis, double delta );


  HepLorentzVector & rotate ( const HepAxisAngle & ax );
  HepLorentzVector & rotate ( const HepEulerAngles & e );
  HepLorentzVector & rotate ( double phi,
                              double theta,
                              double psi );


  HepLorentzVector & boost ( const Hep3Vector & axis, double beta );



  friend HepLorentzVector rotationXOf
    ( const HepLorentzVector & vec, double delta );
  friend HepLorentzVector rotationYOf
    ( const HepLorentzVector & vec, double delta );
  friend HepLorentzVector rotationZOf
    ( const HepLorentzVector & vec, double delta );
  friend HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const Hep3Vector & axis, double delta );
  friend HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const HepAxisAngle & ax );
  friend HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, const HepEulerAngles & e );
  friend HepLorentzVector rotationOf
    ( const HepLorentzVector & vec, double phi,
                                    double theta,
                                    double psi );

  inline friend HepLorentzVector boostXOf
    ( const HepLorentzVector & vec, double beta );
  inline friend HepLorentzVector boostYOf
    ( const HepLorentzVector & vec, double beta );
  inline friend HepLorentzVector boostZOf
    ( const HepLorentzVector & vec, double beta );
  inline friend HepLorentzVector boostOf
    ( const HepLorentzVector & vec, const Hep3Vector & betaVector );
  inline friend HepLorentzVector boostOf
    ( const HepLorentzVector & vec, const Hep3Vector & axis, double beta );

private:

  Hep3Vector pp;
  double ee;

  static double tolerance;
  static double metric;

};



static const HepLorentzVector X_HAT4 = HepLorentzVector( 1, 0, 0, 0 );
static const HepLorentzVector Y_HAT4 = HepLorentzVector( 0, 1, 0, 0 );
static const HepLorentzVector Z_HAT4 = HepLorentzVector( 0, 0, 1, 0 );
static const HepLorentzVector T_HAT4 = HepLorentzVector( 0, 0, 0, 1 );



std::ostream & operator << (std::ostream &, const HepLorentzVector &);


std::istream & operator >> (std::istream &, HepLorentzVector &);


typedef HepLorentzVector HepLorentzVectorD;
typedef HepLorentzVector HepLorentzVectorF;

inline HepLorentzVector operator * (const HepLorentzVector &, double a);
inline HepLorentzVector operator * (double a, const HepLorentzVector &);


       HepLorentzVector operator / (const HepLorentzVector &, double a);





class Tcomponent {
private:
  double t_;
public:
  explicit Tcomponent(double t) : t_(t) {}
  operator double() const { return t_; }
};

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.icc" 1 3
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.icc" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ZMxpv.h" 1 3
# 138 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ZMxpv.h" 3
class CLHEP_vector_exception : public std::exception {
public:
    CLHEP_vector_exception ( const std::string & s1 ) throw();
    virtual const char* what() const throw();
    virtual const char* name() const throw() = 0;
    virtual ~CLHEP_vector_exception() throw() {}
  private:
    std::string message;
};
# 159 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/ZMxpv.h" 3
class ZMxPhysicsVectors : public CLHEP_vector_exception { public: ZMxPhysicsVectors ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxPhysicsVectors() throw() {} };
class ZMxpvSpacelike : public CLHEP_vector_exception { public: ZMxpvSpacelike ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvSpacelike() throw() {} };
class ZMxpvNegativeMass : public CLHEP_vector_exception { public: ZMxpvNegativeMass ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvNegativeMass() throw() {} };
class ZMxpvVectorInputFails : public CLHEP_vector_exception { public: ZMxpvVectorInputFails ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvVectorInputFails() throw() {} };
class ZMxpvIndexRange : public CLHEP_vector_exception { public: ZMxpvIndexRange ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvIndexRange() throw() {} };
class ZMxpvFixedAxis : public CLHEP_vector_exception { public: ZMxpvFixedAxis ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvFixedAxis() throw() {} };



class ZMxpvTachyonic : public CLHEP_vector_exception { public: ZMxpvTachyonic ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvTachyonic() throw() {} };
class ZMxpvZeroVector : public CLHEP_vector_exception { public: ZMxpvZeroVector ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvZeroVector() throw() {} };
class ZMxpvImproperTransformation : public CLHEP_vector_exception { public: ZMxpvImproperTransformation ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvImproperTransformation() throw() {} };
class ZMxpvInfiniteVector : public CLHEP_vector_exception { public: ZMxpvInfiniteVector ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvInfiniteVector() throw() {} };
class ZMxpvInfinity : public CLHEP_vector_exception { public: ZMxpvInfinity ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvInfinity() throw() {} };
class ZMxpvImproperRotation : public CLHEP_vector_exception { public: ZMxpvImproperRotation ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvImproperRotation() throw() {} };
class ZMxpvAmbiguousAngle : public CLHEP_vector_exception { public: ZMxpvAmbiguousAngle ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvAmbiguousAngle() throw() {} };



class ZMxpvNegativeR : public CLHEP_vector_exception { public: ZMxpvNegativeR ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvNegativeR() throw() {} };
class ZMxpvUnusualTheta : public CLHEP_vector_exception { public: ZMxpvUnusualTheta ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvUnusualTheta() throw() {} };
class ZMxpvParallelCols : public CLHEP_vector_exception { public: ZMxpvParallelCols ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvParallelCols() throw() {} };
class ZMxpvNotOrthogonal : public CLHEP_vector_exception { public: ZMxpvNotOrthogonal ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvNotOrthogonal() throw() {} };
class ZMxpvNotSymplectic : public CLHEP_vector_exception { public: ZMxpvNotSymplectic ( const std::string & s ) throw(); virtual const char* name() const throw(); virtual ~ZMxpvNotSymplectic() throw() {} };
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.icc" 2 3



namespace CLHEP {

inline double HepLorentzVector::x() const { return pp.x(); }
inline double HepLorentzVector::y() const { return pp.y(); }
inline double HepLorentzVector::z() const { return pp.z(); }
inline double HepLorentzVector::t() const { return ee; }

inline HepLorentzVector::
HepLorentzVector(double x1, double y1, double z1, double t1)
  : pp(x1, y1, z1), ee(t1) {}

inline HepLorentzVector:: HepLorentzVector(double x1, double y1, double z1)
  : pp(x1, y1, z1), ee(0) {}

inline HepLorentzVector:: HepLorentzVector(double t1)
  : pp(0, 0, 0), ee(t1) {}

inline HepLorentzVector:: HepLorentzVector()
  : pp(0, 0, 0), ee(0) {}

inline HepLorentzVector::HepLorentzVector(const Hep3Vector & p, double e1)
  : pp(p), ee(e1) {}

inline HepLorentzVector::HepLorentzVector(double e1, const Hep3Vector & p)
  : pp(p), ee(e1) {}

inline HepLorentzVector::HepLorentzVector(const HepLorentzVector & p)
  : pp(p.x(), p.y(), p.z()), ee(p.t()) {}

inline HepLorentzVector::~HepLorentzVector() {}

inline HepLorentzVector::operator const Hep3Vector & () const {return pp;}
inline HepLorentzVector::operator Hep3Vector & () { return pp; }

inline void HepLorentzVector::setX(double a) { pp.setX(a); }
inline void HepLorentzVector::setY(double a) { pp.setY(a); }
inline void HepLorentzVector::setZ(double a) { pp.setZ(a); }
inline void HepLorentzVector::setT(double a) { ee = a;}

inline double HepLorentzVector::px() const { return pp.x(); }
inline double HepLorentzVector::py() const { return pp.y(); }
inline double HepLorentzVector::pz() const { return pp.z(); }
inline double HepLorentzVector::e() const { return ee; }

inline void HepLorentzVector::setPx(double a) { pp.setX(a); }
inline void HepLorentzVector::setPy(double a) { pp.setY(a); }
inline void HepLorentzVector::setPz(double a) { pp.setZ(a); }
inline void HepLorentzVector::setE(double a) { ee = a;}

inline Hep3Vector HepLorentzVector::vect() const { return pp; }
inline void HepLorentzVector::setVect(const Hep3Vector &p) { pp = p; }

inline double HepLorentzVector::theta() const { return pp.theta(); }
inline double HepLorentzVector::cosTheta() const { return pp.cosTheta(); }
inline double HepLorentzVector::phi() const { return pp.phi(); }
inline double HepLorentzVector::rho() const { return pp.mag(); }

inline void HepLorentzVector::setTheta(double a) { pp.setTheta(a); }
inline void HepLorentzVector::setPhi(double a) { pp.setPhi(a); }
inline void HepLorentzVector::setRho(double a) { pp.setMag(a); }

double & HepLorentzVector::operator [] (int i) { return (*this)(i); }
double HepLorentzVector::operator [] (int i) const { return (*this)(i); }

inline HepLorentzVector &
HepLorentzVector::operator = (const HepLorentzVector & q) {
  pp = q.vect();
  ee = q.t();
  return *this;
}

inline HepLorentzVector
HepLorentzVector::operator + (const HepLorentzVector & q) const {
  return HepLorentzVector(x()+q.x(), y()+q.y(), z()+q.z(), t()+q.t());
}

inline HepLorentzVector &
HepLorentzVector::operator += (const HepLorentzVector & q) {
  pp += q.vect();
  ee += q.t();
  return *this;
}

inline HepLorentzVector
HepLorentzVector::operator - (const HepLorentzVector & q) const {
  return HepLorentzVector(x()-q.x(), y()-q.y(), z()-q.z(), t()-q.t());
}

inline HepLorentzVector &
HepLorentzVector::operator -= (const HepLorentzVector & q) {
  pp -= q.vect();
  ee -= q.t();
  return *this;
}

inline HepLorentzVector HepLorentzVector::operator - () const {
  return HepLorentzVector(-x(), -y(), -z(), -t());
}

inline HepLorentzVector& HepLorentzVector::operator *= (double a) {
  pp *= a;
  ee *= a;
  return *this;
}

inline bool
HepLorentzVector::operator == (const HepLorentzVector & q) const {
  return (vect()==q.vect() && t()==q.t());
}

inline bool
HepLorentzVector::operator != (const HepLorentzVector & q) const {
  return (vect()!=q.vect() || t()!=q.t());
}

inline double HepLorentzVector::perp2() const { return pp.perp2(); }
inline double HepLorentzVector::perp() const { return pp.perp(); }
inline void HepLorentzVector::setPerp(double a) { pp.setPerp(a); }

inline double HepLorentzVector::perp2(const Hep3Vector &v1) const {
  return pp.perp2(v1);
}

inline double HepLorentzVector::perp(const Hep3Vector &v1) const {
  return pp.perp(v1);
}

inline double HepLorentzVector::angle(const Hep3Vector &v1) const {
  return pp.angle(v1);
}

inline double HepLorentzVector::mag2() const {
  return metric*(t()*t() - pp.mag2());
}

inline double HepLorentzVector::mag() const {
  double mmm = m2();
  return mmm < 0.0 ? -std::sqrt(-mmm) : std::sqrt(mmm);
}

inline double HepLorentzVector::m2() const {
  return t()*t() - pp.mag2();
}

inline double HepLorentzVector::m() const { return mag(); }

inline double HepLorentzVector::mt2() const {
  return e()*e() - pz()*pz();
}

inline double HepLorentzVector::mt() const {
  double mmm = mt2();
  return mmm < 0.0 ? -std::sqrt(-mmm) : std::sqrt(mmm);
}

inline double HepLorentzVector::et2() const {
  double pt2 = pp.perp2();
  return pt2 == 0 ? 0 : e()*e() * pt2/(pt2+z()*z());
}

inline double HepLorentzVector::et() const {
  double etet = et2();
  return e() < 0.0 ? -std::sqrt(etet) : std::sqrt(etet);
}

inline double HepLorentzVector::et2(const Hep3Vector & v1) const {
  double pt2 = pp.perp2(v1);
  double pv = pp.dot(v1.unit());
  return pt2 == 0 ? 0 : e()*e() * pt2/(pt2+pv*pv);
}

inline double HepLorentzVector::et(const Hep3Vector & v1) const {
  double etet = et2(v1);
  return e() < 0.0 ? -std::sqrt(etet) : std::sqrt(etet);
}

inline void
HepLorentzVector::setVectMag(const Hep3Vector & spatial, double magnitude) {
  setVect(spatial);
  setT(std::sqrt(magnitude * magnitude + spatial * spatial));
}

inline void
HepLorentzVector::setVectM(const Hep3Vector & spatial, double mass) {
  setVectMag(spatial, mass);
}

inline double HepLorentzVector::dot(const HepLorentzVector & q) const {
  return metric*(t()*q.t() - z()*q.z() - y()*q.y() - x()*q.x());
}

inline double
HepLorentzVector::operator * (const HepLorentzVector & q) const {
  return dot(q);
}

inline double HepLorentzVector::plus() const {
  return t() + z();
}

inline double HepLorentzVector::minus() const {
  return t() - z();
}

inline HepLorentzVector & HepLorentzVector::boost(const Hep3Vector & b) {
  return boost(b.x(), b.y(), b.z());
}

inline double HepLorentzVector::pseudoRapidity() const {
  return pp.pseudoRapidity();
}

inline double HepLorentzVector::eta() const {
  return pp.pseudoRapidity();
}

inline double HepLorentzVector::eta( const Hep3Vector & ref ) const {
  return pp.eta( ref );
}

inline HepLorentzVector &
HepLorentzVector::operator *= (const HepRotation & m1) {
  pp.transform(m1);
  return *this;
}

inline HepLorentzVector &
HepLorentzVector::transform(const HepRotation & m1) {
  pp.transform(m1);
  return *this;
}

inline HepLorentzVector operator * (const HepLorentzVector & p, double a) {
  return HepLorentzVector(a*p.x(), a*p.y(), a*p.z(), a*p.t());
}

inline HepLorentzVector operator * (double a, const HepLorentzVector & p) {
  return HepLorentzVector(a*p.x(), a*p.y(), a*p.z(), a*p.t());
}



inline HepLorentzVector::HepLorentzVector(
 double x1, double y1, double z1, Tcomponent t1 ) :
 pp(x1, y1, z1), ee(t1) {}

inline void HepLorentzVector::set(
 double x1, double y1, double z1, Tcomponent t1 ) {
  pp.set(x1,y1,z1);
  ee = t1;
}

inline void HepLorentzVector::set(
        double x1, double y1, double z1, double t1 ) {
  set (x1,y1,z1,Tcomponent(t1));
}

inline HepLorentzVector::HepLorentzVector(
 Tcomponent t1, double x1, double y1, double z1 ) :
        pp(x1, y1, z1), ee(t1) {}

inline void HepLorentzVector::set(
 Tcomponent t1, double x1, double y1, double z1 ) {
  pp.set(x1,y1,z1);
  ee = t1;
}

inline void HepLorentzVector::set( Tcomponent t1 ) {
  pp.set(0, 0, 0);
  ee = t1;
}

inline void HepLorentzVector::set( double t1 ) {
  pp.set(0, 0, 0);
  ee = t1;
}

inline HepLorentzVector::HepLorentzVector( Tcomponent t1 ) :
 pp(0, 0, 0), ee(t1) {}

inline void HepLorentzVector::set( const Hep3Vector & v1 ) {
  pp = v1;
  ee = 0;
}

inline HepLorentzVector::HepLorentzVector( const Hep3Vector & v1 ) :
 pp(v1), ee(0) {}

inline void HepLorentzVector::setV(const Hep3Vector & v1) {
  pp = v1;
}

inline HepLorentzVector & HepLorentzVector::operator=(const Hep3Vector & v1) {
  pp = v1;
  ee = 0;
  return *this;
}

inline double HepLorentzVector::getX() const { return pp.x(); }
inline double HepLorentzVector::getY() const { return pp.y(); }
inline double HepLorentzVector::getZ() const { return pp.z(); }
inline double HepLorentzVector::getT() const { return ee; }

inline Hep3Vector HepLorentzVector::getV() const { return pp; }
inline Hep3Vector HepLorentzVector::v() const { return pp; }

inline void HepLorentzVector::set(double t1, const Hep3Vector & v1) {
  pp = v1;
  ee = t1;
}

inline void HepLorentzVector::set(const Hep3Vector & v1, double t1) {
  pp = v1;
  ee = t1;
}

inline void HepLorentzVector::setV( double x1,
             double y1,
             double z1 ) { pp.set(x1, y1, z1); }

inline void HepLorentzVector::setRThetaPhi
  ( double r, double ttheta, double phi1 )
                         { pp.setRThetaPhi( r, ttheta, phi1 ); }

inline void HepLorentzVector::setREtaPhi
  ( double r, double eta1, double phi1 )
                         { pp.setREtaPhi( r, eta1, phi1 ); }

inline void HepLorentzVector::setRhoPhiZ
  ( double rho1, double phi1, double z1 )
                         { pp.setRhoPhiZ ( rho1, phi1, z1 ); }

inline bool HepLorentzVector::isTimelike() const {
  return restMass2() > 0;
}

inline bool HepLorentzVector::isSpacelike() const {
  return restMass2() < 0;
}

inline bool HepLorentzVector::isLightlike(double epsilon) const {
  return std::fabs(restMass2()) < 2.0 * epsilon * ee * ee;
}

inline double HepLorentzVector::diff2( const HepLorentzVector & w ) const {
    return metric*( (ee-w.ee)*(ee-w.ee) - (pp-w.pp).mag2() );
}

inline double HepLorentzVector::delta2Euclidean
     ( const HepLorentzVector & w ) const {
    return (ee-w.ee)*(ee-w.ee) + (pp-w.pp).mag2();
}

inline double HepLorentzVector::euclideanNorm2() const {
  return ee*ee + pp.mag2();
}

inline double HepLorentzVector::euclideanNorm() const {
  return std::sqrt(euclideanNorm2());
}

inline double HepLorentzVector::restMass2() const { return m2(); }
inline double HepLorentzVector::invariantMass2() const { return m2(); }

inline double HepLorentzVector::restMass() const {
    if( t() < 0.0 ) do { std::cerr << ZMxpvNegativeMass( "E^2-p^2 < 0 for this particle. Magnitude returned.").name() << ":\n" << ZMxpvNegativeMass( "E^2-p^2 < 0 for this particle. Magnitude returned.").what() << "\n" << "at line " << 381 << " in file " << "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.icc" << "\n"; } while (0);

    return t() < 0.0 ? -m() : m();
}

inline double HepLorentzVector::invariantMass() const {
    if( t() < 0.0 ) do { std::cerr << ZMxpvNegativeMass( "E^2-p^2 < 0 for this particle. Magnitude returned.").name() << ":\n" << ZMxpvNegativeMass( "E^2-p^2 < 0 for this particle. Magnitude returned.").what() << "\n" << "at line " << 387 << " in file " << "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.icc" << "\n"; } while (0);

    return t() < 0.0 ? -m() : m();
}

inline double HepLorentzVector::invariantMass2
     (const HepLorentzVector & w) const {
  return (*this + w).m2();
}







inline HepLorentzVector boostXOf
 (const HepLorentzVector & vec, double bbeta) {
  HepLorentzVector vv (vec);
  return vv.boostX (bbeta);
}

inline HepLorentzVector boostYOf
 (const HepLorentzVector & vec, double bbeta) {
  HepLorentzVector vv (vec);
  return vv.boostY (bbeta);
}

inline HepLorentzVector boostZOf
 (const HepLorentzVector & vec, double bbeta) {
  HepLorentzVector vv (vec);
  return vv.boostZ (bbeta);
}

inline HepLorentzVector boostOf
 (const HepLorentzVector & vec, const Hep3Vector & betaVector ) {
  HepLorentzVector vv (vec);
  return vv.boost (betaVector);
}

inline HepLorentzVector boostOf
    (const HepLorentzVector & vec, const Hep3Vector & aaxis, double bbeta) {
  HepLorentzVector vv (vec);
  return vv.boost (aaxis, bbeta);
}

}
# 572 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/LorentzVector.h" 2 3
# 71 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/AxisAngle.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/AxisAngle.h" 3
namespace CLHEP {



class HepAxisAngle;
std::ostream & operator<<( std::ostream & os, const HepAxisAngle & aa );
std::istream & operator>>( std::istream & is, HepAxisAngle & aa );





class HepAxisAngle {

public:
  typedef double Scalar;

protected:
  typedef HepAxisAngle AA;
  static Scalar tolerance;

public:


  inline HepAxisAngle();
  inline HepAxisAngle( const Hep3Vector axis, Scalar delta );






public:
  inline Hep3Vector getAxis() const;
  inline Hep3Vector axis() const;
  inline AA & setAxis( const Hep3Vector axis );

  inline double getDelta() const;
  inline double delta() const ;
  inline AA & setDelta( Scalar delta );

  inline AA & set( const Hep3Vector axis, Scalar delta );




  inline int compare ( const AA & aa ) const;

  inline bool operator==( const AA & aa ) const;
  inline bool operator!=( const AA & aa ) const;
  inline bool operator< ( const AA & aa ) const;
  inline bool operator<=( const AA & aa ) const;
  inline bool operator> ( const AA & aa ) const;
  inline bool operator>=( const AA & aa ) const;


  inline static double getTolerance();
  inline static double setTolerance( Scalar tol );

protected:
    double distance( const HepAxisAngle & aa ) const;
public:

  bool isNear ( const AA & aa, Scalar epsilon = tolerance ) const;
  double howNear( const AA & aa ) const;



  friend std::ostream & operator<<( std::ostream & os, const AA & aa );
  friend std::istream & operator>>( std::istream & is, AA & aa );

private:
  Hep3Vector axis_;
  double delta_;

};


}


namespace zmpv {

  typedef CLHEP::HepAxisAngle AxisAngle;

}



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/AxisAngle.icc" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/AxisAngle.icc" 3
namespace CLHEP {

inline HepAxisAngle::HepAxisAngle() :
  axis_( Hep3Vector(0,0,1) ), delta_( 0.0 )
{}

inline HepAxisAngle::HepAxisAngle( const Hep3Vector aaxis, Scalar ddelta ) :
  axis_( aaxis.unit() ), delta_( ddelta )
{}


inline Hep3Vector HepAxisAngle::getAxis() const {
  return axis_;
}

inline Hep3Vector HepAxisAngle::axis() const {
  return axis_;
}


inline HepAxisAngle & HepAxisAngle::setAxis( const Hep3Vector aaxis ) {
  axis_ = aaxis.unit();
  return *this;
}


inline double HepAxisAngle::getDelta() const {
  return delta_;
}

inline double HepAxisAngle::delta() const {
  return delta_;
}


inline HepAxisAngle & HepAxisAngle::setDelta( Scalar ddelta ) {
  delta_ = ddelta;
  return *this;
}


inline HepAxisAngle & HepAxisAngle::set( const Hep3Vector aaxis, Scalar ddelta ) {
  axis_ = aaxis.unit();
  delta_ = ddelta;
  return *this;
}


inline int HepAxisAngle::compare( const AA & aa ) const {

  return delta_ < aa.delta_ ? -1
       : delta_ > aa.delta_ ? +1
       : axis_ < aa.axis_ ? -1
       : axis_ > aa.axis_ ? +1
       : 0;

}


inline bool HepAxisAngle::operator==( const AA & aa ) const {
  return ( compare( aa ) == 0 );
}


inline bool HepAxisAngle::operator!=( const AA & aa ) const {
  return ( compare( aa ) != 0 );
}


inline bool HepAxisAngle::operator<( const AA & aa ) const {
  return ( compare( aa ) < 0 );
}


inline bool HepAxisAngle::operator<=( const AA & aa ) const {
  return ( compare( aa ) <= 0 );
}


inline bool HepAxisAngle::operator>( const AA & aa ) const {
  return ( compare( aa ) > 0 );
}


inline bool HepAxisAngle::operator>=( const AA & aa ) const {
  return ( compare( aa ) >= 0 );
}


inline double HepAxisAngle::getTolerance() {
  return tolerance;
}


inline double HepAxisAngle::setTolerance( Scalar tol ) {
  Scalar oldTolerance( tolerance );
  tolerance = tol;
  return oldTolerance;
}

}
# 115 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/AxisAngle.h" 2 3
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 2 3

namespace CLHEP {

struct HepRep3x3;
struct HepRep4x4;
struct HepRep4x4Symmetric;

class HepRotation;
class HepRotationX;
class HepRotationY;
class HepRotationZ;
class HepLorentzRotation;
class HepBoost;
class HepBoostX;
class HepBoostY;
class HepBoostZ;
# 99 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 3
class Hep4RotationInterface {





  friend class HepRotation;
  friend class HepRotationX;
  friend class HepRotationY;
  friend class HepRotationZ;
  friend class HepLorentzRotation;
  friend class HepBoost;
  friend class HepBoostX;
  friend class HepBoostY;
  friend class HepBoostZ;

public:

  static double tolerance;
# 193 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 3
  static double getTolerance();
  static double setTolerance( double tol );

  static const int ToleranceTicks = 100;

protected:

  ~Hep4RotationInterface() {}

};
# 215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 3
class Hep3RotationInterface : public Hep4RotationInterface {




  friend class HepRotation;
  friend class HepRotationX;
  friend class HepRotationY;
  friend class HepRotationZ;

public:
# 296 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 3
private:

  ~Hep3RotationInterface() {}

};





struct HepRep3x3 {



  inline HepRep3x3();

  inline HepRep3x3( double xx, double xy, double xz
                   , double yx, double yy, double yz
                   , double zx, double zy, double zz
                   );

  inline HepRep3x3( const double * array );



  inline void setToIdentity();


  double xx_, xy_, xz_,
            yx_, yy_, yz_,
            zx_, zy_, zz_;

  inline void getArray ( double * array ) const;


};

struct HepRep4x4 {


  inline HepRep4x4();

  inline HepRep4x4( double xx, double xy, double xz, double xt
                   , double yx, double yy, double yz, double yt
                   , double zx, double zy, double zz, double zt
                   , double tx, double ty, double tz, double tt
                   );

  inline HepRep4x4( const HepRep4x4Symmetric & rep );

  inline HepRep4x4( const double * array );



  inline void setToIdentity();


  double xx_, xy_, xz_, xt_,
            yx_, yy_, yz_, yt_,
            zx_, zy_, zz_, zt_,
            tx_, ty_, tz_, tt_;

  inline void getArray ( double * array ) const;


  inline bool operator==(HepRep4x4 const & r) const;
  inline bool operator!=(HepRep4x4 const & r) const;


};

struct HepRep4x4Symmetric {



  inline HepRep4x4Symmetric();

  inline HepRep4x4Symmetric
 ( double xx, double xy, double xz, double xt
                      , double yy, double yz, double yt
                                    , double zz, double zt
                                                  , double tt );

  inline HepRep4x4Symmetric( const double * array );



  inline void setToIdentity();


  double xx_, xy_, xz_, xt_,
                 yy_, yz_, yt_,
                      zz_, zt_,
                           tt_;

  inline void getArray ( double * array ) const;


};

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.icc" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.icc" 3
namespace CLHEP {





inline HepRep3x3::HepRep3x3() :
   xx_(1.0), xy_(0.0), xz_(0.0)
 , yx_(0.0), yy_(1.0), yz_(0.0)
 , zx_(0.0), zy_(0.0), zz_(1.0)
{}

inline HepRep3x3::HepRep3x3( double xx, double xy, double xz
                   , double yx, double yy, double yz
                   , double zx, double zy, double zz
                   ) :
   xx_(xx), xy_(xy), xz_(xz)
 , yx_(yx), yy_(yy), yz_(yz)
 , zx_(zx), zy_(zy), zz_(zz)
{}

inline HepRep3x3::HepRep3x3( const double * array ) {
  const double * a = array;
  double * r = &xx_;
  for ( int i = 0; i < 9; i++ ) { *r++ = *a++; }
}

inline void HepRep3x3::setToIdentity() {
   xx_ = 1.0; xy_ = 0.0; xz_ = 0.0;
   yx_ = 0.0; yy_ = 1.0; yz_ = 0.0;
   zx_ = 0.0; zy_ = 0.0; zz_ = 1.0;
}

inline void HepRep3x3::getArray( double * array ) const {
  double * a = array;
  const double * r = &xx_;
  for ( int i = 0; i < 9; i++ ) { *a++ = *r++; }
}






inline HepRep4x4::HepRep4x4() :
   xx_(1.0), xy_(0.0), xz_(0.0), xt_(0.0)
 , yx_(0.0), yy_(1.0), yz_(0.0), yt_(0.0)
 , zx_(0.0), zy_(0.0), zz_(1.0), zt_(0.0)
 , tx_(0.0), ty_(0.0), tz_(0.0), tt_(1.0)
{}

inline HepRep4x4::HepRep4x4(
       double xx, double xy, double xz, double xt
                   , double yx, double yy, double yz, double yt
                   , double zx, double zy, double zz, double zt
                   , double tx, double ty, double tz, double tt
                   ) :
   xx_(xx), xy_(xy), xz_(xz), xt_(xt)
 , yx_(yx), yy_(yy), yz_(yz), yt_(yt)
 , zx_(zx), zy_(zy), zz_(zz), zt_(zt)
 , tx_(tx), ty_(ty), tz_(tz), tt_(tt)
{}

inline HepRep4x4::HepRep4x4( const HepRep4x4Symmetric & rep ) :
   xx_(rep.xx_), xy_(rep.xy_), xz_(rep.xz_), xt_(rep.xt_)
 , yx_(rep.xy_), yy_(rep.yy_), yz_(rep.yz_), yt_(rep.yt_)
 , zx_(rep.xz_), zy_(rep.yz_), zz_(rep.zz_), zt_(rep.zt_)
 , tx_(rep.xt_), ty_(rep.yt_), tz_(rep.zt_), tt_(rep.tt_)
{}

inline HepRep4x4::HepRep4x4( const double * array ) {
  const double * a = array;
  double * r = &xx_;
  for ( int i = 0; i < 16; i++ ) { *r++ = *a++; }
}

inline void HepRep4x4::setToIdentity() {
   xx_ = 1.0; xy_ = 0.0; xz_ = 0.0; xt_ = 0.0;
   yx_ = 0.0; yy_ = 1.0; yz_ = 0.0; yt_ = 0.0;
   zx_ = 0.0; zy_ = 0.0; zz_ = 1.0; zt_ = 0.0;
   tx_ = 0.0; ty_ = 0.0; tz_ = 0.0; tt_ = 1.0;
}

inline void HepRep4x4::getArray( double * array ) const {
  double * a = array;
  const double * r = &xx_;
  for ( int i = 0; i < 16; i++ ) { *a++ = *r++; }
}

inline bool HepRep4x4::operator == (const HepRep4x4 & r) const {
  return( xx_ == r.xx_ && xy_ == r.xy_ && xz_ == r.xz_ && xt_ == r.xt_ &&
          yx_ == r.yx_ && yy_ == r.yy_ && yz_ == r.yz_ && yt_ == r.yt_ &&
          zx_ == r.zx_ && zy_ == r.zy_ && zz_ == r.zz_ && zt_ == r.zt_ &&
          tx_ == r.tx_ && ty_ == r.ty_ && tz_ == r.tz_ && tt_ == r.tt_ );
}

inline bool HepRep4x4::operator != (const HepRep4x4 & r) const {
  return !(operator== (r));
}





inline HepRep4x4Symmetric::HepRep4x4Symmetric() :
   xx_(1.0), xy_(0.0), xz_(0.0), xt_(0.0)
 , yy_(1.0), yz_(0.0), yt_(0.0)
 , zz_(1.0), zt_(0.0)
 , tt_(1.0)
{}

inline HepRep4x4Symmetric::HepRep4x4Symmetric
        ( double xx, double xy, double xz, double xt
                      , double yy, double yz, double yt
                                    , double zz, double zt
                                                  , double tt ) :
   xx_(xx), xy_(xy), xz_(xz), xt_(xt)
   , yy_(yy), yz_(yz), yt_(yt)
     , zz_(zz), zt_(zt)
       , tt_(tt)
{}

inline HepRep4x4Symmetric::HepRep4x4Symmetric( const double * array ) {
  const double * a = array;
  double * r = &xx_;
  for ( int i = 0; i < 10; i++ ) { *r++ = *a++; }
}

inline void HepRep4x4Symmetric::setToIdentity() {
   xx_ = 1.0; xy_ = 0.0; xz_ = 0.0; xt_ = 0.0;
              yy_ = 1.0; yz_ = 0.0; yt_ = 0.0;
                         zz_ = 1.0; zt_ = 0.0;
                                    tt_ = 1.0;
}

inline void HepRep4x4Symmetric::getArray( double * array ) const {
  double * a = array;
  const double * r = &xx_;
  for ( int i = 0; i < 10; i++ ) { *a++ = *r++; }
}

}
# 399 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationInterfaces.h" 2 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.h" 3
namespace CLHEP {

class HepRotationX;

class HepRotation;
class HepBoost;

inline HepRotationX inverseOf(const HepRotationX & r);






class HepRotationX {

public:



  inline HepRotationX();


  HepRotationX(double delta);


  inline HepRotationX(const HepRotationX & orig);
  inline HepRotationX(HepRotationX && orig) = default;


  inline HepRotationX & operator = (const HepRotationX & r);
  inline HepRotationX & operator = (HepRotationX && r) = default;


  HepRotationX & set ( double delta );


  inline ~HepRotationX();




  inline Hep3Vector colX() const;
  inline Hep3Vector colY() const;
  inline Hep3Vector colZ() const;


  inline Hep3Vector rowX() const;
  inline Hep3Vector rowY() const;
  inline Hep3Vector rowZ() const;


  inline double xx() const;
  inline double xy() const;
  inline double xz() const;
  inline double yx() const;
  inline double yy() const;
  inline double yz() const;
  inline double zx() const;
  inline double zy() const;
  inline double zz() const;


  inline HepRep3x3 rep3x3() const;



  inline double getPhi () const;
  inline double getTheta() const;
  inline double getPsi () const;
  double phi () const;
  double theta() const;
  double psi () const;
  HepEulerAngles eulerAngles() const;


  inline double getDelta() const;
  inline Hep3Vector getAxis () const;
  inline double delta() const;
  inline Hep3Vector axis () const;
  inline HepAxisAngle axisAngle() const;
  inline void getAngleAxis(double & delta, Hep3Vector & axis) const;



  double phiX() const;
  double phiY() const;
  double phiZ() const;
  double thetaX() const;
  double thetaY() const;
  double thetaZ() const;




  inline HepLorentzVector col1() const;
  inline HepLorentzVector col2() const;
  inline HepLorentzVector col3() const;


  inline HepLorentzVector col4() const;


  inline HepLorentzVector row1() const;
  inline HepLorentzVector row2() const;
  inline HepLorentzVector row3() const;


  inline HepLorentzVector row4() const;


  inline double xt() const;
  inline double yt() const;
  inline double zt() const;
  inline double tx() const;
  inline double ty() const;
  inline double tz() const;


  inline double tt() const;


  inline HepRep4x4 rep4x4() const;




  void setDelta (double delta);




  void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
  void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
  void decompose (HepRotation & rotation, HepBoost & boost) const;
  void decompose (HepBoost & boost, HepRotation & rotation) const;




  inline bool isIdentity() const;


  inline int compare( const HepRotationX & r ) const;



  inline bool operator== ( const HepRotationX & r ) const;
  inline bool operator!= ( const HepRotationX & r ) const;
  inline bool operator< ( const HepRotationX & r ) const;
  inline bool operator> ( const HepRotationX & r ) const;
  inline bool operator<= ( const HepRotationX & r ) const;
  inline bool operator>= ( const HepRotationX & r ) const;

  double distance2( const HepRotationX & r ) const;


  double distance2( const HepRotation & r ) const;


  double howNear( const HepRotationX & r ) const;
  double howNear( const HepRotation & r ) const;
  bool isNear( const HepRotationX & r,
               double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepRotation & r,
               double epsilon=Hep4RotationInterface::tolerance) const;

  double distance2( const HepBoost & lt ) const;

  double distance2( const HepLorentzRotation & lt ) const;


  double howNear( const HepBoost & lt ) const;
  double howNear( const HepLorentzRotation & lt ) const;
  bool isNear( const HepBoost & lt,
               double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepLorentzRotation & lt,
               double epsilon=Hep4RotationInterface::tolerance) const;



  double norm2() const;


  inline void rectify();




  inline Hep3Vector operator() (const Hep3Vector & p) const;


  inline Hep3Vector operator * (const Hep3Vector & p) const;


  inline HepLorentzVector operator()( const HepLorentzVector & w ) const;


  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;




  inline HepRotationX operator * (const HepRotationX & rx) const;


  inline HepRotationX & operator *= (const HepRotationX & r);
  inline HepRotationX & transform (const HepRotationX & r);




  inline HepRotationX inverse() const;


  friend HepRotationX inverseOf(const HepRotationX & r);


  inline HepRotationX & invert();




  std::ostream & print( std::ostream & os ) const;




  static inline double getTolerance();
  static inline double setTolerance(double tol);

protected:

  double its_d;


  double its_s;
  double its_c;


  inline HepRotationX ( double dd, double ss, double cc );


  static inline double proper (double delta);


};


inline
std::ostream & operator <<
 ( std::ostream & os, const HepRotationX & r ) {return r.print(os);}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.icc" 1 3
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.icc" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/PhysicalConstants.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/PhysicalConstants.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/defs.h" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/PhysicalConstants.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/SystemOfUnits.h" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/SystemOfUnits.h" 3
namespace CLHEP {




  static constexpr double pi = 3.14159265358979323846;
  static constexpr double twopi = 2*pi;
  static constexpr double halfpi = pi/2;
  static constexpr double pi2 = pi*pi;




  static constexpr double millimeter = 1.;
  static constexpr double millimeter2 = millimeter*millimeter;
  static constexpr double millimeter3 = millimeter*millimeter*millimeter;

  static constexpr double centimeter = 10.*millimeter;
  static constexpr double centimeter2 = centimeter*centimeter;
  static constexpr double centimeter3 = centimeter*centimeter*centimeter;

  static constexpr double meter = 1000.*millimeter;
  static constexpr double meter2 = meter*meter;
  static constexpr double meter3 = meter*meter*meter;

  static constexpr double kilometer = 1000.*meter;
  static constexpr double kilometer2 = kilometer*kilometer;
  static constexpr double kilometer3 = kilometer*kilometer*kilometer;

  static constexpr double parsec = 3.0856775807e+16*meter;

  static constexpr double micrometer = 1.e-6 *meter;
  static constexpr double nanometer = 1.e-9 *meter;
  static constexpr double angstrom = 1.e-10*meter;
  static constexpr double fermi = 1.e-15*meter;

  static constexpr double barn = 1.e-28*meter2;
  static constexpr double millibarn = 1.e-3 *barn;
  static constexpr double microbarn = 1.e-6 *barn;
  static constexpr double nanobarn = 1.e-9 *barn;
  static constexpr double picobarn = 1.e-12*barn;


  static constexpr double nm = nanometer;
  static constexpr double um = micrometer;

  static constexpr double mm = millimeter;
  static constexpr double mm2 = millimeter2;
  static constexpr double mm3 = millimeter3;

  static constexpr double cm = centimeter;
  static constexpr double cm2 = centimeter2;
  static constexpr double cm3 = centimeter3;

  static constexpr double liter = 1.e+3*cm3;
  static constexpr double L = liter;
  static constexpr double dL = 1.e-1*liter;
  static constexpr double cL = 1.e-2*liter;
  static constexpr double mL = 1.e-3*liter;

  static constexpr double m = meter;
  static constexpr double m2 = meter2;
  static constexpr double m3 = meter3;

  static constexpr double km = kilometer;
  static constexpr double km2 = kilometer2;
  static constexpr double km3 = kilometer3;

  static constexpr double pc = parsec;




  static constexpr double radian = 1.;
  static constexpr double milliradian = 1.e-3*radian;
  static constexpr double degree = (pi/180.0)*radian;

  static constexpr double steradian = 1.;


  static constexpr double rad = radian;
  static constexpr double mrad = milliradian;
  static constexpr double sr = steradian;
  static constexpr double deg = degree;




  static constexpr double nanosecond = 1.;
  static constexpr double second = 1.e+9 *nanosecond;
  static constexpr double millisecond = 1.e-3 *second;
  static constexpr double microsecond = 1.e-6 *second;
  static constexpr double picosecond = 1.e-12*second;

  static constexpr double minute = 60*second;
  static constexpr double hour = 60*minute;
  static constexpr double day = 24*hour;
  static constexpr double year = 365*day;

  static constexpr double hertz = 1./second;
  static constexpr double kilohertz = 1.e+3*hertz;
  static constexpr double megahertz = 1.e+6*hertz;


  static constexpr double ns = nanosecond;
  static constexpr double s = second;
  static constexpr double ms = millisecond;
  static constexpr double us = microsecond;
  static constexpr double ps = picosecond;




  static constexpr double eplus = 1. ;
  static constexpr double e_SI = 1.602176634e-19;
  static constexpr double coulomb = eplus/e_SI;




  static constexpr double megaelectronvolt = 1. ;
  static constexpr double electronvolt = 1.e-6*megaelectronvolt;
  static constexpr double kiloelectronvolt = 1.e-3*megaelectronvolt;
  static constexpr double gigaelectronvolt = 1.e+3*megaelectronvolt;
  static constexpr double teraelectronvolt = 1.e+6*megaelectronvolt;
  static constexpr double petaelectronvolt = 1.e+9*megaelectronvolt;
  static constexpr double millielectronvolt = 1.e-9*megaelectronvolt;

  static constexpr double joule = electronvolt/e_SI;


  static constexpr double MeV = megaelectronvolt;
  static constexpr double eV = electronvolt;
  static constexpr double keV = kiloelectronvolt;
  static constexpr double GeV = gigaelectronvolt;
  static constexpr double TeV = teraelectronvolt;
  static constexpr double PeV = petaelectronvolt;




  static constexpr double kilogram = joule*second*second/(meter*meter);
  static constexpr double gram = 1.e-3*kilogram;
  static constexpr double milligram = 1.e-3*gram;


  static constexpr double kg = kilogram;
  static constexpr double g = gram;
  static constexpr double mg = milligram;




  static constexpr double watt = joule/second;




  static constexpr double newton = joule/meter;





  static constexpr double hep_pascal = newton/m2;
  static constexpr double bar = 100000*hep_pascal;
  static constexpr double atmosphere = 101325*hep_pascal;




  static constexpr double ampere = coulomb/second;
  static constexpr double milliampere = 1.e-3*ampere;
  static constexpr double microampere = 1.e-6*ampere;
  static constexpr double nanoampere = 1.e-9*ampere;




  static constexpr double megavolt = megaelectronvolt/eplus;
  static constexpr double kilovolt = 1.e-3*megavolt;
  static constexpr double volt = 1.e-6*megavolt;




  static constexpr double ohm = volt/ampere;




  static constexpr double farad = coulomb/volt;
  static constexpr double millifarad = 1.e-3*farad;
  static constexpr double microfarad = 1.e-6*farad;
  static constexpr double nanofarad = 1.e-9*farad;
  static constexpr double picofarad = 1.e-12*farad;




  static constexpr double weber = volt*second;




  static constexpr double tesla = volt*second/meter2;

  static constexpr double gauss = 1.e-4*tesla;
  static constexpr double kilogauss = 1.e-1*tesla;




  static constexpr double henry = weber/ampere;




  static constexpr double kelvin = 1.;




  static constexpr double mole = 1.;




  static constexpr double becquerel = 1./second ;
  static constexpr double curie = 3.7e+10 * becquerel;
  static constexpr double kilobecquerel = 1.e+3*becquerel;
  static constexpr double megabecquerel = 1.e+6*becquerel;
  static constexpr double gigabecquerel = 1.e+9*becquerel;
  static constexpr double millicurie = 1.e-3*curie;
  static constexpr double microcurie = 1.e-6*curie;
  static constexpr double Bq = becquerel;
  static constexpr double kBq = kilobecquerel;
  static constexpr double MBq = megabecquerel;
  static constexpr double GBq = gigabecquerel;
  static constexpr double Ci = curie;
  static constexpr double mCi = millicurie;
  static constexpr double uCi = microcurie;




  static constexpr double gray = joule/kilogram ;
  static constexpr double kilogray = 1.e+3*gray;
  static constexpr double milligray = 1.e-3*gray;
  static constexpr double microgray = 1.e-6*gray;




  static constexpr double candela = 1.;




  static constexpr double lumen = candela*steradian;




  static constexpr double lux = lumen/meter2;




  static constexpr double perCent = 0.01 ;
  static constexpr double perThousand = 0.001;
  static constexpr double perMillion = 0.000001;

}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Units/PhysicalConstants.h" 2 3

namespace CLHEP {




static constexpr double Avogadro = 6.02214076e+23/mole;





static constexpr double c_light = 2.99792458e+8 * m/s;
static constexpr double c_squared = c_light * c_light;






static constexpr double h_Planck = 6.62607015e-34 * joule*s;
static constexpr double hbar_Planck = h_Planck/twopi;
static constexpr double hbarc = hbar_Planck * c_light;
static constexpr double hbarc_squared = hbarc * hbarc;




static constexpr double electron_charge = - eplus;
static constexpr double e_squared = eplus * eplus;






static constexpr double electron_mass_c2 = 0.510998910 * MeV;
static constexpr double proton_mass_c2 = 938.272013 * MeV;
static constexpr double neutron_mass_c2 = 939.56536 * MeV;
static constexpr double amu_c2 = 931.494028 * MeV;
static constexpr double amu = amu_c2/c_squared;





static constexpr double mu0 = 4*pi*1.e-7 * henry/m;
static constexpr double epsilon0 = 1./(c_squared*mu0);




static constexpr double elm_coupling = e_squared/(4*pi*epsilon0);
static constexpr double fine_structure_const = elm_coupling/hbarc;
static constexpr double classic_electr_radius = elm_coupling/electron_mass_c2;
static constexpr double electron_Compton_length = hbarc/electron_mass_c2;
static constexpr double Bohr_radius = electron_Compton_length/fine_structure_const;

static constexpr double alpha_rcl2 = fine_structure_const
                                   *classic_electr_radius
                                   *classic_electr_radius;

static constexpr double twopi_mc2_rcl2 = twopi*electron_mass_c2
                                             *classic_electr_radius
                                             *classic_electr_radius;

static constexpr double Bohr_magneton = (eplus*hbarc*c_light)/(2*electron_mass_c2);
static constexpr double nuclear_magneton = (eplus*hbarc*c_light)/(2*proton_mass_c2);




static constexpr double k_Boltzmann = 8.617333e-11 * MeV/kelvin;




static constexpr double STP_Temperature = 273.15*kelvin;
static constexpr double STP_Pressure = 1.*atmosphere;
static constexpr double kGasThreshold = 10.*mg/cm3;




static constexpr double universe_mean_density = 1.e-25*g/cm3;

}
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.icc" 2 3

namespace CLHEP {

inline double HepRotationX::yy() const { return its_c; }
inline double HepRotationX::yz() const { return -its_s; }
inline double HepRotationX::zy() const { return its_s; }
inline double HepRotationX::zz() const { return its_c; }

inline double HepRotationX::xx() const { return 1.0; }
inline double HepRotationX::xy() const { return 0.0; }
inline double HepRotationX::xz() const { return 0.0; }
inline double HepRotationX::yx() const { return 0.0; }
inline double HepRotationX::zx() const { return 0.0; }

inline HepRep3x3 HepRotationX::rep3x3() const {
  return HepRep3x3 ( 1.0, 0.0, 0.0,
                     0.0, its_c, -its_s,
                     0.0, its_s, its_c );
}

inline HepRotationX::HepRotationX() : its_d(0.0), its_s(0.0), its_c(1.0) {}

inline HepRotationX::HepRotationX(const HepRotationX & orig) :
 its_d(orig.its_d), its_s(orig.its_s), its_c(orig.its_c)
{}

inline HepRotationX::HepRotationX(double dd, double ss, double cc) :
 its_d(dd), its_s(ss), its_c(cc)
{}

inline HepRotationX & HepRotationX::operator= (const HepRotationX & orig) {
  its_d = orig.its_d;
  its_s = orig.its_s;
  its_c = orig.its_c;
  return *this;
}

inline HepRotationX::~HepRotationX() {}

inline Hep3Vector HepRotationX::colX() const
    { return Hep3Vector ( 1.0, 0.0, 0.0 ); }
inline Hep3Vector HepRotationX::colY() const
    { return Hep3Vector ( 0.0, its_c, its_s ); }
inline Hep3Vector HepRotationX::colZ() const
    { return Hep3Vector ( 0.0, -its_s, its_c ); }

inline Hep3Vector HepRotationX::rowX() const
    { return Hep3Vector ( 1.0, 0.0, 0.0 ); }
inline Hep3Vector HepRotationX::rowY() const
    { return Hep3Vector ( 0.0, its_c, -its_s ); }
inline Hep3Vector HepRotationX::rowZ() const
    { return Hep3Vector ( 0.0, its_s, its_c ); }

inline double HepRotationX::getPhi () const { return phi(); }
inline double HepRotationX::getTheta() const { return theta(); }
inline double HepRotationX::getPsi () const { return psi(); }
inline double HepRotationX::getDelta() const { return its_d; }
inline Hep3Vector HepRotationX::getAxis () const { return axis(); }

inline double HepRotationX::delta() const { return its_d; }
inline Hep3Vector HepRotationX::axis() const { return Hep3Vector(1,0,0); }

inline HepAxisAngle HepRotationX::axisAngle() const {
  return HepAxisAngle ( axis(), delta() );
}

inline void HepRotationX::getAngleAxis
   (double & ddelta, Hep3Vector & aaxis) const {
  ddelta = its_d;
  aaxis = getAxis();
}

inline HepLorentzVector HepRotationX::col1() const
    { return HepLorentzVector (colX(), 0); }
inline HepLorentzVector HepRotationX::col2() const
    { return HepLorentzVector (colY(), 0); }
inline HepLorentzVector HepRotationX::col3() const
    { return HepLorentzVector (colZ(), 0); }
inline HepLorentzVector HepRotationX::col4() const
    { return HepLorentzVector (0,0,0,1); }
inline HepLorentzVector HepRotationX::row1() const
    { return HepLorentzVector (rowX(), 0); }
inline HepLorentzVector HepRotationX::row2() const
    { return HepLorentzVector (rowY(), 0); }
inline HepLorentzVector HepRotationX::row3() const
    { return HepLorentzVector (rowZ(), 0); }
inline HepLorentzVector HepRotationX::row4() const
    { return HepLorentzVector (0,0,0,1); }
inline double HepRotationX::xt() const { return 0.0; }
inline double HepRotationX::yt() const { return 0.0; }
inline double HepRotationX::zt() const { return 0.0; }
inline double HepRotationX::tx() const { return 0.0; }
inline double HepRotationX::ty() const { return 0.0; }
inline double HepRotationX::tz() const { return 0.0; }
inline double HepRotationX::tt() const { return 1.0; }

inline HepRep4x4 HepRotationX::rep4x4() const {
  return HepRep4x4 ( 1.0, 0.0, 0.0, 0.0,
                     0.0, its_c, -its_s, 0.0,
                     0.0, its_s, its_c, 0.0,
                     0.0, 0.0, 0.0, 1.0 );
}

inline bool HepRotationX::isIdentity() const {
  return ( its_d==0 );
}

inline int HepRotationX::compare ( const HepRotationX & r ) const {
  if (its_d > r.its_d) return 1; else if (its_d < r.its_d) return -1; else return 0;
}

inline bool HepRotationX::operator==(const HepRotationX & r) const
  { return (its_d==r.its_d); }
inline bool HepRotationX::operator!=(const HepRotationX & r) const
  { return (its_d!=r.its_d); }
inline bool HepRotationX::operator>=(const HepRotationX & r) const
  { return (its_d>=r.its_d); }
inline bool HepRotationX::operator<=(const HepRotationX & r) const
  { return (its_d<=r.its_d); }
inline bool HepRotationX::operator> (const HepRotationX & r) const
  { return (its_d> r.its_d); }
inline bool HepRotationX::operator< (const HepRotationX & r) const
  { return (its_d< r.its_d); }

inline void HepRotationX::rectify() {
  its_d = proper(its_d);
  its_s = std::sin(its_d);
  its_c = std::cos(its_d);
}

inline Hep3Vector HepRotationX::operator() (const Hep3Vector & p) const {
  double x = p.x();
  double y = p.y();
  double z = p.z();
  return Hep3Vector( x,
                       y * its_c - z * its_s,
                       z * its_c + y * its_s );
}

inline Hep3Vector HepRotationX::operator * (const Hep3Vector & p) const {
  return operator()(p);
}

inline HepLorentzVector HepRotationX::operator()
   ( const HepLorentzVector & w ) const {
  return HepLorentzVector( operator() (w.vect()) , w.t() );
}

inline HepLorentzVector HepRotationX::operator *
     (const HepLorentzVector & p) const {
  return operator()(p);
}

inline HepRotationX & HepRotationX::operator *= (const HepRotationX & m1) {
  return *this = (*this) * (m1);
}

inline HepRotationX & HepRotationX::transform(const HepRotationX & m1) {
  return *this = m1 * (*this);
}

inline double HepRotationX::proper( double ddelta ) {

  if ( std::fabs(ddelta) < CLHEP::pi ) {
    return ddelta;
  } else {
    double x = ddelta / (CLHEP::twopi);
    return (CLHEP::twopi) * ( x + std::floor(.5-x) );
  }
}

inline HepRotationX HepRotationX::operator * ( const HepRotationX & rx ) const {
  return HepRotationX ( HepRotationX::proper(its_d+rx.its_d),
                        its_s*rx.its_c + its_c*rx.its_s,
                        its_c*rx.its_c - its_s*rx.its_s );
}

inline HepRotationX HepRotationX::inverse() const {
  return HepRotationX( proper(-its_d), -its_s, its_c );
}

inline HepRotationX inverseOf(const HepRotationX & r) {
  return r.inverse();
}

inline HepRotationX & HepRotationX::invert() {
  return *this=inverse();
}

inline double HepRotationX::getTolerance() {
  return Hep4RotationInterface::tolerance;
}
inline double HepRotationX::setTolerance(double tol) {
  return Hep4RotationInterface::setTolerance(tol);
}

}
# 282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationX.h" 2 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationY.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationY.h" 3
namespace CLHEP {

class HepRotationY;
class HepRotation;
class HepBoost;

inline HepRotationY inverseOf(const HepRotationY & r);






class HepRotationY {

public:



  inline HepRotationY();


  HepRotationY(double delta);


  inline HepRotationY(const HepRotationY & orig);
  inline HepRotationY(HepRotationY && orig) = default;


  inline HepRotationY & operator = (const HepRotationY & r);
  inline HepRotationY & operator = (HepRotationY && r) = default;


  HepRotationY & set ( double delta );


  inline ~HepRotationY();




  inline Hep3Vector colX() const;
  inline Hep3Vector colY() const;
  inline Hep3Vector colZ() const;


  inline Hep3Vector rowX() const;
  inline Hep3Vector rowY() const;
  inline Hep3Vector rowZ() const;


  inline double xx() const;
  inline double xy() const;
  inline double xz() const;
  inline double yx() const;
  inline double yy() const;
  inline double yz() const;
  inline double zx() const;
  inline double zy() const;
  inline double zz() const;


  inline HepRep3x3 rep3x3() const;



  inline double getPhi () const;
  inline double getTheta() const;
  inline double getPsi () const;
  double phi () const;
  double theta() const;
  double psi () const;
  HepEulerAngles eulerAngles() const;


  inline double getDelta() const;
  inline Hep3Vector getAxis () const;
  inline double delta() const;
  inline Hep3Vector axis () const;
  inline HepAxisAngle axisAngle() const;
  inline void getAngleAxis(double & delta, Hep3Vector & axis) const;



  double phiX() const;
  double phiY() const;
  double phiZ() const;
  double thetaX() const;
  double thetaY() const;
  double thetaZ() const;




  inline HepLorentzVector col1() const;
  inline HepLorentzVector col2() const;
  inline HepLorentzVector col3() const;


  inline HepLorentzVector col4() const;


  inline HepLorentzVector row1() const;
  inline HepLorentzVector row2() const;
  inline HepLorentzVector row3() const;


  inline HepLorentzVector row4() const;


  inline double xt() const;
  inline double yt() const;
  inline double zt() const;
  inline double tx() const;
  inline double ty() const;
  inline double tz() const;


  inline double tt() const;


  inline HepRep4x4 rep4x4() const;




  void setDelta (double delta);




  void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
  void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
  void decompose (HepRotation & rotation, HepBoost & boost) const;
  void decompose (HepBoost & boost, HepRotation & rotation) const;




  inline bool isIdentity() const;


  inline int compare( const HepRotationY & r ) const;



  inline bool operator== ( const HepRotationY & r ) const;
  inline bool operator!= ( const HepRotationY & r ) const;
  inline bool operator< ( const HepRotationY & r ) const;
  inline bool operator> ( const HepRotationY & r ) const;
  inline bool operator<= ( const HepRotationY & r ) const;
  inline bool operator>= ( const HepRotationY & r ) const;

  double distance2( const HepRotationY & r ) const;


  double distance2( const HepRotation & r ) const;


  double howNear( const HepRotationY & r ) const;
  double howNear( const HepRotation & r ) const;
  bool isNear( const HepRotationY & r,
             double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepRotation & r,
             double epsilon=Hep4RotationInterface::tolerance) const;

  double distance2( const HepBoost & lt ) const;

  double distance2( const HepLorentzRotation & lt ) const;


  double howNear( const HepBoost & lt ) const;
  double howNear( const HepLorentzRotation & lt ) const;
  bool isNear( const HepBoost & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepLorentzRotation & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;



  double norm2() const;


  inline void rectify();




  inline Hep3Vector operator() (const Hep3Vector & p) const;


  inline Hep3Vector operator * (const Hep3Vector & p) const;


  inline HepLorentzVector operator()( const HepLorentzVector & w ) const;


  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;




  inline HepRotationY operator * (const HepRotationY & ry) const;


  inline HepRotationY & operator *= (const HepRotationY & r);
  inline HepRotationY & transform (const HepRotationY & r);




  inline HepRotationY inverse() const;


  friend HepRotationY inverseOf(const HepRotationY & r);


  inline HepRotationY & invert();




  std::ostream & print( std::ostream & os ) const;




  static inline double getTolerance();
  static inline double setTolerance(double tol);

protected:

  double its_d;


  double its_s;
  double its_c;


  inline HepRotationY ( double dd, double ss, double cc );


  static inline double proper (double delta);


};



inline
std::ostream & operator <<
 ( std::ostream & os, const HepRotationY & r ) {return r.print(os);}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationY.icc" 1 3
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationY.icc" 3
namespace CLHEP {

inline double HepRotationY::xx() const { return its_c; }
inline double HepRotationY::xz() const { return its_s; }
inline double HepRotationY::zx() const { return -its_s; }
inline double HepRotationY::zz() const { return its_c; }

inline double HepRotationY::yy() const { return 1.0; }
inline double HepRotationY::yx() const { return 0.0; }
inline double HepRotationY::yz() const { return 0.0; }
inline double HepRotationY::xy() const { return 0.0; }
inline double HepRotationY::zy() const { return 0.0; }

inline HepRep3x3 HepRotationY::rep3x3() const {
  return HepRep3x3 ( its_c , 0.0, its_s,
                     0.0, 1.0, 0.0,
                    -its_s , 0.0, its_c );
}

inline HepRotationY::HepRotationY() : its_d(0.0), its_s(0.0), its_c(1.0) {}

inline HepRotationY::HepRotationY(const HepRotationY & orig) :
 its_d(orig.its_d), its_s(orig.its_s), its_c(orig.its_c)
{}

inline HepRotationY::HepRotationY(double dd, double ss, double cc) :
 its_d(dd), its_s(ss), its_c(cc)
{}

inline HepRotationY & HepRotationY::operator= (const HepRotationY & orig) {
  its_d = orig.its_d;
  its_s = orig.its_s;
  its_c = orig.its_c;
  return *this;
}

inline HepRotationY::~HepRotationY() {}

inline Hep3Vector HepRotationY::colX() const
    { return Hep3Vector ( its_c, 0.0, -its_s ); }
inline Hep3Vector HepRotationY::colY() const
    { return Hep3Vector ( 0.0, 1.0, 0.0 ); }
inline Hep3Vector HepRotationY::colZ() const
    { return Hep3Vector ( its_s, 0.0, its_c ); }

inline Hep3Vector HepRotationY::rowX() const
    { return Hep3Vector ( its_c, 0.0, its_s ); }
inline Hep3Vector HepRotationY::rowY() const
    { return Hep3Vector ( 0.0, 1.0, 0.0 ); }
inline Hep3Vector HepRotationY::rowZ() const
    { return Hep3Vector ( -its_s, 0.0, its_c ); }

inline double HepRotationY::getPhi () const { return phi(); }
inline double HepRotationY::getTheta() const { return theta(); }
inline double HepRotationY::getPsi () const { return psi(); }
inline double HepRotationY::getDelta() const { return its_d; }
inline Hep3Vector HepRotationY::getAxis () const { return axis(); }

inline double HepRotationY::delta() const { return its_d; }
inline Hep3Vector HepRotationY::axis() const { return Hep3Vector(0,1,0); }

inline HepAxisAngle HepRotationY::axisAngle() const {
  return HepAxisAngle ( axis(), delta() );
}

inline void HepRotationY::getAngleAxis
   (double & ddelta, Hep3Vector & aaxis) const {
  ddelta = its_d;
  aaxis = getAxis();
}

inline bool HepRotationY::isIdentity() const {
  return ( its_d==0 );
}

inline int HepRotationY::compare ( const HepRotationY & r ) const {
  if (its_d > r.its_d) return 1; else if (its_d < r.its_d) return -1; else return 0;
}


inline bool HepRotationY::operator==(const HepRotationY & r) const
  { return (its_d==r.its_d); }
inline bool HepRotationY::operator!=(const HepRotationY & r) const
  { return (its_d!=r.its_d); }
inline bool HepRotationY::operator>=(const HepRotationY & r) const
  { return (its_d>=r.its_d); }
inline bool HepRotationY::operator<=(const HepRotationY & r) const
  { return (its_d<=r.its_d); }
inline bool HepRotationY::operator> (const HepRotationY & r) const
  { return (its_d> r.its_d); }
inline bool HepRotationY::operator< (const HepRotationY & r) const
  { return (its_d< r.its_d); }

inline void HepRotationY::rectify() {
  its_d = proper(its_d);
  its_s = std::sin(its_d);
  its_c = std::cos(its_d);
}

inline Hep3Vector HepRotationY::operator() (const Hep3Vector & p) const {
  double x = p.x();
  double y = p.y();
  double z = p.z();
  return Hep3Vector( x * its_c + z * its_s,
                             y,
                       z * its_c - x * its_s );
}

inline Hep3Vector HepRotationY::operator * (const Hep3Vector & p) const {
  return operator()(p);
}

inline HepLorentzVector HepRotationY::operator()
   ( const HepLorentzVector & w ) const {
  return HepLorentzVector( operator() (w.vect()) , w.t() );
}

inline HepLorentzVector HepRotationY::operator *
                                        (const HepLorentzVector & p) const {
  return operator()(p);
}

inline HepRotationY & HepRotationY::operator *= (const HepRotationY & m1) {
  return *this = (*this) * (m1);
}

inline HepRotationY & HepRotationY::transform(const HepRotationY & m1) {
  return *this = m1 * (*this);
}

inline double HepRotationY::proper( double ddelta ) {

  if ( std::fabs(ddelta) < CLHEP::pi ) {
    return ddelta;
  } else {
    double x = ddelta / (CLHEP::twopi);
    return (CLHEP::twopi) * ( x + std::floor(.5-x) );
  }
}

inline HepRotationY HepRotationY::operator * ( const HepRotationY & ry ) const {
  return HepRotationY ( HepRotationY::proper(its_d+ry.its_d),
                        its_s*ry.its_c + its_c*ry.its_s,
                        its_c*ry.its_c - its_s*ry.its_s );
}

inline HepRotationY HepRotationY::inverse() const {
  return HepRotationY( proper(-its_d), -its_s, its_c );
}

inline HepRotationY inverseOf(const HepRotationY & r) {
  return r.inverse();
}

inline HepRotationY & HepRotationY::invert() {
  return *this=inverse();
}

inline HepLorentzVector HepRotationY::col1() const
                                { return HepLorentzVector (colX(), 0); }
inline HepLorentzVector HepRotationY::col2() const
                                { return HepLorentzVector (colY(), 0); }
inline HepLorentzVector HepRotationY::col3() const
                                { return HepLorentzVector (colZ(), 0); }
inline HepLorentzVector HepRotationY::col4() const
                                { return HepLorentzVector (0,0,0,1); }
inline HepLorentzVector HepRotationY::row1() const
                                { return HepLorentzVector (rowX(), 0); }
inline HepLorentzVector HepRotationY::row2() const
                                { return HepLorentzVector (rowY(), 0); }
inline HepLorentzVector HepRotationY::row3() const
                                { return HepLorentzVector (rowZ(), 0); }
inline HepLorentzVector HepRotationY::row4() const
                                { return HepLorentzVector (0,0,0,1); }
inline double HepRotationY::xt() const { return 0.0; }
inline double HepRotationY::yt() const { return 0.0; }
inline double HepRotationY::zt() const { return 0.0; }
inline double HepRotationY::tx() const { return 0.0; }
inline double HepRotationY::ty() const { return 0.0; }
inline double HepRotationY::tz() const { return 0.0; }
inline double HepRotationY::tt() const { return 1.0; }

inline HepRep4x4 HepRotationY::rep4x4() const {
  return HepRep4x4 ( its_c , 0.0, its_s, 0.0,
                     0.0, 1.0, 0.0, 0.0,
                     -its_s, 0.0, its_c, 0.0,
                     0.0, 0.0, 0.0, 1.0 );
}

inline double HepRotationY::getTolerance() {
  return Hep4RotationInterface::tolerance;
}
inline double HepRotationY::setTolerance(double tol) {
  return Hep4RotationInterface::setTolerance(tol);
}

}
# 282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationY.h" 2 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationZ.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationZ.h" 3
namespace CLHEP {

class HepRotationZ;
class HepRotation;
class HepBoost;

inline HepRotationZ inverseOf(const HepRotationZ & r);






class HepRotationZ {

public:



  inline HepRotationZ();


  HepRotationZ(double delta);


  inline HepRotationZ(const HepRotationZ & orig);
  inline HepRotationZ(HepRotationZ && orig) = default;


  inline HepRotationZ & operator = (const HepRotationZ & r);
  inline HepRotationZ & operator = (HepRotationZ && r) = default;


  HepRotationZ & set ( double delta );


  inline ~HepRotationZ();




  inline Hep3Vector colX() const;
  inline Hep3Vector colY() const;
  inline Hep3Vector colZ() const;


  inline Hep3Vector rowX() const;
  inline Hep3Vector rowY() const;
  inline Hep3Vector rowZ() const;


  inline double xx() const;
  inline double xy() const;
  inline double xz() const;
  inline double yx() const;
  inline double yy() const;
  inline double yz() const;
  inline double zx() const;
  inline double zy() const;
  inline double zz() const;


  inline HepRep3x3 rep3x3() const;



  inline double getPhi () const;
  inline double getTheta() const;
  inline double getPsi () const;
  double phi () const;
  double theta() const;
  double psi () const;
  HepEulerAngles eulerAngles() const;


  inline double getDelta() const;
  inline Hep3Vector getAxis () const;
  inline double delta() const;
  inline Hep3Vector axis () const;
  inline HepAxisAngle axisAngle() const;
  inline void getAngleAxis(double & delta, Hep3Vector & axis) const;



  double phiX() const;
  double phiY() const;
  double phiZ() const;
  double thetaX() const;
  double thetaY() const;
  double thetaZ() const;




  inline HepLorentzVector col1() const;
  inline HepLorentzVector col2() const;
  inline HepLorentzVector col3() const;


  inline HepLorentzVector col4() const;


  inline HepLorentzVector row1() const;
  inline HepLorentzVector row2() const;
  inline HepLorentzVector row3() const;


  inline HepLorentzVector row4() const;


  inline double xt() const;
  inline double yt() const;
  inline double zt() const;
  inline double tx() const;
  inline double ty() const;
  inline double tz() const;


  inline double tt() const;


  inline HepRep4x4 rep4x4() const;




  void setDelta (double delta);




  void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
  void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;
  void decompose (HepRotation & rotation, HepBoost & boost) const;
  void decompose (HepBoost & boost, HepRotation & rotation) const;




  inline bool isIdentity() const;


  inline int compare( const HepRotationZ & r ) const;



  inline bool operator== ( const HepRotationZ & r ) const;
  inline bool operator!= ( const HepRotationZ & r ) const;
  inline bool operator< ( const HepRotationZ & r ) const;
  inline bool operator> ( const HepRotationZ & r ) const;
  inline bool operator<= ( const HepRotationZ & r ) const;
  inline bool operator>= ( const HepRotationZ & r ) const;

  double distance2( const HepRotationZ & r ) const;


  double distance2( const HepRotation & r ) const;


  double howNear( const HepRotationZ & r ) const;
  double howNear( const HepRotation & r ) const;
  bool isNear( const HepRotationZ & r,
             double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepRotation & r,
             double epsilon=Hep4RotationInterface::tolerance) const;

  double distance2( const HepBoost & lt ) const;

  double distance2( const HepLorentzRotation & lt ) const;


  double howNear( const HepBoost & lt ) const;
  double howNear( const HepLorentzRotation & lt ) const;
  bool isNear( const HepBoost & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepLorentzRotation & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;



  double norm2() const;


  inline void rectify();




  inline Hep3Vector operator() (const Hep3Vector & p) const;


  inline Hep3Vector operator * (const Hep3Vector & p) const;


  inline HepLorentzVector operator()( const HepLorentzVector & w ) const;


  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;




  inline HepRotationZ operator * (const HepRotationZ & rz) const;




  inline HepRotationZ & operator *= (const HepRotationZ & r);
  inline HepRotationZ & transform (const HepRotationZ & r);




  inline HepRotationZ inverse() const;


  friend HepRotationZ inverseOf(const HepRotationZ & r);


  inline HepRotationZ & invert();




  std::ostream & print( std::ostream & os ) const;




  static inline double getTolerance();
  static inline double setTolerance(double tol);

protected:

  double its_d;


  double its_s;
  double its_c;


  inline HepRotationZ ( double dd, double ss, double cc );


  static inline double proper (double delta);


};

inline
std::ostream & operator <<
 ( std::ostream & os, const HepRotationZ & r ) {return r.print(os);}



}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationZ.icc" 1 3
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationZ.icc" 3
namespace CLHEP {

inline double HepRotationZ::xx() const { return its_c; }
inline double HepRotationZ::xy() const { return -its_s; }
inline double HepRotationZ::yx() const { return its_s; }
inline double HepRotationZ::yy() const { return its_c; }

inline double HepRotationZ::zz() const { return 1.0; }
inline double HepRotationZ::zy() const { return 0.0; }
inline double HepRotationZ::zx() const { return 0.0; }
inline double HepRotationZ::yz() const { return 0.0; }
inline double HepRotationZ::xz() const { return 0.0; }

inline HepRep3x3 HepRotationZ::rep3x3() const {
  return HepRep3x3 ( its_c, -its_s, 0.0,
                     its_s, its_c, 0.0,
                     0.0, 0.0, 1.0 );
}

inline HepRotationZ::HepRotationZ() : its_d(0.0), its_s(0.0), its_c(1.0) {}

inline HepRotationZ::HepRotationZ(const HepRotationZ & orig) :
 its_d(orig.its_d), its_s(orig.its_s), its_c(orig.its_c)
{}

inline HepRotationZ::HepRotationZ(double dd, double ss, double cc) :
 its_d(dd), its_s(ss), its_c(cc)
{}

inline HepRotationZ & HepRotationZ::operator= (const HepRotationZ & orig) {
  its_d = orig.its_d;
  its_s = orig.its_s;
  its_c = orig.its_c;
  return *this;
}

inline HepRotationZ::~HepRotationZ() {}

inline Hep3Vector HepRotationZ::colX() const
    { return Hep3Vector ( its_c, its_s, 0.0 ); }
inline Hep3Vector HepRotationZ::colY() const
    { return Hep3Vector ( -its_s, its_c, 0.0 ); }
inline Hep3Vector HepRotationZ::colZ() const
    { return Hep3Vector ( 0.0, 0.0, 1.0 ); }

inline Hep3Vector HepRotationZ::rowX() const
    { return Hep3Vector ( its_c, -its_s, 0.0 ); }
inline Hep3Vector HepRotationZ::rowY() const
    { return Hep3Vector ( its_s, its_c, 0.0 ); }
inline Hep3Vector HepRotationZ::rowZ() const
    { return Hep3Vector ( 0.0, 0.0, 1.0 ); }

inline double HepRotationZ::getPhi () const { return phi(); }
inline double HepRotationZ::getTheta() const { return theta(); }
inline double HepRotationZ::getPsi () const { return psi(); }
inline double HepRotationZ::getDelta() const { return its_d; }
inline Hep3Vector HepRotationZ::getAxis () const { return axis(); }

inline double HepRotationZ::delta() const { return its_d; }
inline Hep3Vector HepRotationZ::axis() const { return Hep3Vector(0,0,1); }

inline HepAxisAngle HepRotationZ::axisAngle() const {
  return HepAxisAngle ( axis(), delta() );
}

inline void HepRotationZ::getAngleAxis
   (double & ddelta, Hep3Vector & aaxis) const {
  ddelta = its_d;
  aaxis = getAxis();
}

inline bool HepRotationZ::isIdentity() const {
  return ( its_d==0 );
}

inline int HepRotationZ::compare ( const HepRotationZ & r ) const {
  if (its_d > r.its_d) return 1; else if (its_d < r.its_d) return -1; else return 0;
}

inline bool HepRotationZ::operator==(const HepRotationZ & r) const
  { return (its_d==r.its_d); }
inline bool HepRotationZ::operator!=(const HepRotationZ & r) const
  { return (its_d!=r.its_d); }
inline bool HepRotationZ::operator>=(const HepRotationZ & r) const
  { return (its_d>=r.its_d); }
inline bool HepRotationZ::operator<=(const HepRotationZ & r) const
  { return (its_d<=r.its_d); }
inline bool HepRotationZ::operator> (const HepRotationZ & r) const
  { return (its_d> r.its_d); }
inline bool HepRotationZ::operator< (const HepRotationZ & r) const
  { return (its_d< r.its_d); }

inline void HepRotationZ::rectify() {
  its_d = proper(its_d);
  its_s = std::sin(its_d);
  its_c = std::cos(its_d);
}

inline Hep3Vector HepRotationZ::operator() (const Hep3Vector & p) const {
  double x = p.x();
  double y = p.y();
  double z = p.z();
  return Hep3Vector( x * its_c - y * its_s,
                       x * its_s + y * its_c,
                             z );
}

inline Hep3Vector HepRotationZ::operator * (const Hep3Vector & p) const {
  return operator()(p);
}

inline HepLorentzVector HepRotationZ::operator()
   ( const HepLorentzVector & w ) const {
  return HepLorentzVector( operator() (w.vect()) , w.t() );
}

inline HepLorentzVector HepRotationZ::operator *
                                        (const HepLorentzVector & p) const {
  return operator()(p);
}

inline HepRotationZ & HepRotationZ::operator *= (const HepRotationZ & m1) {
  return *this = (*this) * (m1);
}

inline HepRotationZ & HepRotationZ::transform(const HepRotationZ & m1) {
  return *this = m1 * (*this);
}

inline double HepRotationZ::proper( double ddelta ) {

  if ( std::fabs(ddelta) < CLHEP::pi ) {
    return ddelta;
  } else {
    double x = ddelta / (CLHEP::twopi);
    return (CLHEP::twopi) * ( x + std::floor(.5-x) );
  }
}

inline HepRotationZ HepRotationZ::operator * ( const HepRotationZ & rz ) const {
  return HepRotationZ ( HepRotationZ::proper(its_d+rz.its_d),
                        its_s*rz.its_c + its_c*rz.its_s,
                        its_c*rz.its_c - its_s*rz.its_s );
}

inline HepRotationZ HepRotationZ::inverse() const {
  return HepRotationZ( proper(-its_d), -its_s, its_c );
}

inline HepRotationZ inverseOf(const HepRotationZ & r) {
  return r.inverse();
}

inline HepRotationZ & HepRotationZ::invert() {
  return *this=inverse();
}

inline HepLorentzVector HepRotationZ::col1() const
                                { return HepLorentzVector (colX(), 0); }
inline HepLorentzVector HepRotationZ::col2() const
                                { return HepLorentzVector (colY(), 0); }
inline HepLorentzVector HepRotationZ::col3() const
                                { return HepLorentzVector (colZ(), 0); }
inline HepLorentzVector HepRotationZ::col4() const
                                { return HepLorentzVector (0,0,0,1); }
inline HepLorentzVector HepRotationZ::row1() const
                                { return HepLorentzVector (rowX(), 0); }
inline HepLorentzVector HepRotationZ::row2() const
                                { return HepLorentzVector (rowY(), 0); }
inline HepLorentzVector HepRotationZ::row3() const
                                { return HepLorentzVector (rowZ(), 0); }
inline HepLorentzVector HepRotationZ::row4() const
                                { return HepLorentzVector (0,0,0,1); }
inline double HepRotationZ::xt() const { return 0.0; }
inline double HepRotationZ::yt() const { return 0.0; }
inline double HepRotationZ::zt() const { return 0.0; }
inline double HepRotationZ::tx() const { return 0.0; }
inline double HepRotationZ::ty() const { return 0.0; }
inline double HepRotationZ::tz() const { return 0.0; }
inline double HepRotationZ::tt() const { return 1.0; }

inline HepRep4x4 HepRotationZ::rep4x4() const {
  return HepRep4x4 ( its_c, -its_s, 0.0, 0.0,
                     its_s, its_c, 0.0, 0.0,
                     0.0, 0.0, 1.0, 0.0,
                     0.0, 0.0, 0.0, 1.0 );
}

inline double HepRotationZ::getTolerance() {
  return Hep4RotationInterface::tolerance;
}
inline double HepRotationZ::setTolerance(double tol) {
  return Hep4RotationInterface::setTolerance(tol);
}

}
# 284 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/RotationZ.h" 2 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 2 3


namespace CLHEP {


class HepRotation;
inline HepRotation inverseOf ( const HepRotation & r );
inline HepRotation operator * (const HepRotationX & rx, const HepRotation & r);
inline HepRotation operator * (const HepRotationY & ry, const HepRotation & r);
inline HepRotation operator * (const HepRotationZ & rz, const HepRotation & r);





class HepRotation {

public:



  inline HepRotation();


  inline HepRotation(const HepRotation & m);
  inline HepRotation(HepRotation && m) = default;


  inline HepRotation(const HepRotationX & m);
  inline HepRotation(const HepRotationY & m);
  inline HepRotation(const HepRotationZ & m);


  HepRotation & set( const Hep3Vector & axis, double delta );
  HepRotation ( const Hep3Vector & axis, double delta );


  HepRotation & set( const HepAxisAngle & ax );
  HepRotation ( const HepAxisAngle & ax );


  HepRotation & set( double phi, double theta, double psi );
  HepRotation ( double phi, double theta, double psi );


  HepRotation & set( const HepEulerAngles & e );
  HepRotation ( const HepEulerAngles & e );


  HepRotation ( const Hep3Vector & colX,
                const Hep3Vector & colY,
                const Hep3Vector & colZ );







  HepRotation & set( const Hep3Vector & colX,
                             const Hep3Vector & colY,
                             const Hep3Vector & colZ );


  HepRotation & setRows( const Hep3Vector & rowX,
                                 const Hep3Vector & rowY,
                                 const Hep3Vector & rowZ );


  inline HepRotation & set(const HepRotationX & r);
  inline HepRotation & set(const HepRotationY & r);
  inline HepRotation & set(const HepRotationZ & r);


  inline HepRotation & operator = (const HepRotation & r);
  inline HepRotation & operator = (HepRotation && r) = default;


  inline HepRotation & operator = (const HepRotationX & r);
  inline HepRotation & operator = (const HepRotationY & r);
  inline HepRotation & operator = (const HepRotationZ & r);


  inline HepRotation &set( const HepRep3x3 & m );
  inline HepRotation ( const HepRep3x3 & m );




  inline ~HepRotation();




  inline Hep3Vector colX() const;
  inline Hep3Vector colY() const;
  inline Hep3Vector colZ() const;


  inline Hep3Vector rowX() const;
  inline Hep3Vector rowY() const;
  inline Hep3Vector rowZ() const;


  inline double xx() const;
  inline double xy() const;
  inline double xz() const;
  inline double yx() const;
  inline double yy() const;
  inline double yz() const;
  inline double zx() const;
  inline double zy() const;
  inline double zz() const;


  inline HepRep3x3 rep3x3() const;




  class HepRotation_row {
  public:
    inline HepRotation_row(const HepRotation &, int);
    inline double operator [] (int) const;
  private:
    const HepRotation & rr;
    int ii;
  };


  inline const HepRotation_row operator [] (int) const;



  double operator () (int, int) const;




  inline double getPhi () const;
  inline double getTheta() const;
  inline double getPsi () const;
  double phi () const;
  double theta() const;
  double psi () const;
  HepEulerAngles eulerAngles() const;


  inline double getDelta() const;
  inline Hep3Vector getAxis () const;
  double delta() const;
  Hep3Vector axis () const;
  HepAxisAngle axisAngle() const;
  void getAngleAxis(double & delta, Hep3Vector & axis) const;



  double phiX() const;
  double phiY() const;
  double phiZ() const;
  double thetaX() const;
  double thetaY() const;
  double thetaZ() const;





  inline HepLorentzVector col1() const;
  inline HepLorentzVector col2() const;
  inline HepLorentzVector col3() const;


  inline HepLorentzVector col4() const;


  inline HepLorentzVector row1() const;
  inline HepLorentzVector row2() const;
  inline HepLorentzVector row3() const;


  inline HepLorentzVector row4() const;


  inline double xt() const;
  inline double yt() const;
  inline double zt() const;
  inline double tx() const;
  inline double ty() const;
  inline double tz() const;


  inline double tt() const;


  inline HepRep4x4 rep4x4() const;




  void setPhi (double phi);


  void setTheta (double theta);


  void setPsi (double psi);


  void setAxis (const Hep3Vector & axis);


  void setDelta (double delta);




  void decompose (HepAxisAngle & rotation, Hep3Vector & boost) const;
  void decompose (Hep3Vector & boost, HepAxisAngle & rotation) const;




  bool isIdentity() const;


  int compare( const HepRotation & r ) const;



  inline bool operator== ( const HepRotation & r ) const;
  inline bool operator!= ( const HepRotation & r ) const;
  inline bool operator< ( const HepRotation & r ) const;
  inline bool operator> ( const HepRotation & r ) const;
  inline bool operator<= ( const HepRotation & r ) const;
  inline bool operator>= ( const HepRotation & r ) const;

  double distance2( const HepRotation & r ) const;


  double howNear( const HepRotation & r ) const;
  bool isNear( const HepRotation & r,
             double epsilon=Hep4RotationInterface::tolerance) const;

  double distance2( const HepBoost & lt ) const;

  double distance2( const HepLorentzRotation & lt ) const;


  double howNear( const HepBoost & lt ) const;
  double howNear( const HepLorentzRotation & lt ) const;
  bool isNear( const HepBoost & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;
  bool isNear( const HepLorentzRotation & lt,
             double epsilon=Hep4RotationInterface::tolerance) const;



  double norm2() const;


  void rectify();
# 300 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 3
  inline Hep3Vector operator() (const Hep3Vector & p) const;


  inline Hep3Vector operator * (const Hep3Vector & p) const;


  inline HepLorentzVector operator()( const HepLorentzVector & w ) const;


  inline HepLorentzVector operator* ( const HepLorentzVector & w ) const;




  inline HepRotation operator * (const HepRotation & r) const;


  inline HepRotation operator * (const HepRotationX & rx) const;
  inline HepRotation operator * (const HepRotationY & ry) const;
  inline HepRotation operator * (const HepRotationZ & rz) const;


  inline HepRotation & operator *= (const HepRotation & r);
  inline HepRotation & transform (const HepRotation & r);



  inline HepRotation & operator *= (const HepRotationX & r);
  inline HepRotation & operator *= (const HepRotationY & r);
  inline HepRotation & operator *= (const HepRotationZ & r);
  inline HepRotation & transform (const HepRotationX & r);
  inline HepRotation & transform (const HepRotationY & r);
  inline HepRotation & transform (const HepRotationZ & r);


  HepRotation & rotateX(double delta);


  HepRotation & rotateY(double delta);


  HepRotation & rotateZ(double delta);


         HepRotation & rotate(double delta, const Hep3Vector & axis);
  inline HepRotation & rotate(double delta, const Hep3Vector * axis);



  HepRotation & rotateAxes(const Hep3Vector & newX,
                           const Hep3Vector & newY,
                           const Hep3Vector & newZ);



  inline HepRotation inverse() const;


  inline HepRotation & invert();




  std::ostream & print( std::ostream & os ) const;




  static const HepRotation IDENTITY;



  static inline double getTolerance();
  static inline double setTolerance(double tol);

protected:

  inline HepRotation(double mxx, double mxy, double mxz,
       double myx, double myy, double myz,
       double mzx, double mzy, double mzz);



  friend HepRotation operator* (const HepRotationX & rx, const HepRotation & r);
  friend HepRotation operator* (const HepRotationY & ry, const HepRotation & r);
  friend HepRotation operator* (const HepRotationZ & rz, const HepRotation & r);

  double rxx, rxy, rxz,
     ryx, ryy, ryz,
     rzx, rzy, rzz;


private:
  bool
       setCols ( const Hep3Vector & u1,
                 const Hep3Vector & u2,
                 const Hep3Vector & u3,
                 double u1u2,
                 Hep3Vector & v1,
                 Hep3Vector & v2,
                 Hep3Vector & v3 ) const;
  void setArbitrarily (const Hep3Vector & colX,
                      Hep3Vector & v1,
                      Hep3Vector & v2,
                      Hep3Vector & v3) const;
};

inline
std::ostream & operator <<
 ( std::ostream & os, const HepRotation & r ) {return r.print(os);}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.icc" 1 3
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.icc" 3
namespace CLHEP {



inline double HepRotation::xx() const { return rxx; }
inline double HepRotation::xy() const { return rxy; }
inline double HepRotation::xz() const { return rxz; }
inline double HepRotation::yx() const { return ryx; }
inline double HepRotation::yy() const { return ryy; }
inline double HepRotation::yz() const { return ryz; }
inline double HepRotation::zx() const { return rzx; }
inline double HepRotation::zy() const { return rzy; }
inline double HepRotation::zz() const { return rzz; }

inline HepRep3x3 HepRotation::rep3x3() const {
  return HepRep3x3 ( rxx, rxy, rxz,
       ryx, ryy, ryz,
       rzx, rzy, rzz );
}

inline double HepRotation::xt() const { return 0.0; }
inline double HepRotation::yt() const { return 0.0; }
inline double HepRotation::zt() const { return 0.0; }
inline double HepRotation::tx() const { return 0.0; }
inline double HepRotation::ty() const { return 0.0; }
inline double HepRotation::tz() const { return 0.0; }
inline double HepRotation::tt() const { return 1.0; }

inline HepRep4x4 HepRotation::rep4x4() const {
  return HepRep4x4 ( rxx, rxy, rxz, 0.0,
       ryx, ryy, ryz, 0.0,
       rzx, rzy, rzz, 0.0,
       0.0, 0.0, 0.0, 1.0 );
}



inline HepRotation::HepRotation() : rxx(1.0), rxy(0.0), rxz(0.0),
        ryx(0.0), ryy(1.0), ryz(0.0),
        rzx(0.0), rzy(0.0), rzz(1.0) {}

inline HepRotation::HepRotation(const HepRotation & m1) :
 rxx(m1.rxx), rxy(m1.rxy), rxz(m1.rxz),
 ryx(m1.ryx), ryy(m1.ryy), ryz(m1.ryz),
 rzx(m1.rzx), rzy(m1.rzy), rzz(m1.rzz) {}

inline HepRotation::HepRotation
   (double mxx, double mxy, double mxz,
    double myx, double myy, double myz,
    double mzx, double mzy, double mzz) :
 rxx(mxx), rxy(mxy), rxz(mxz),
 ryx(myx), ryy(myy), ryz(myz),
 rzx(mzx), rzy(mzy), rzz(mzz) {}

inline HepRotation::HepRotation ( const HepRep3x3 & m1 ) :
 rxx(m1.xx_), rxy(m1.xy_), rxz(m1.xz_),
 ryx(m1.yx_), ryy(m1.yy_), ryz(m1.yz_),
 rzx(m1.zx_), rzy(m1.zy_), rzz(m1.zz_) {}

inline HepRotation::HepRotation(const HepRotationX & rx) :
 rxx(1.0), rxy(0.0), rxz(0.0),
 ryx(0.0), ryy(rx.yy()), ryz(rx.yz()),
 rzx(0.0), rzy(rx.zy()), rzz(rx.zz()) {}

inline HepRotation::HepRotation(const HepRotationY & ry) :
 rxx(ry.xx()), rxy(0.0), rxz(ry.xz()),
 ryx(0.0), ryy(1.0), ryz(0.0),
 rzx(ry.zx()), rzy(0.0), rzz(ry.zz()) {}

inline HepRotation::HepRotation(const HepRotationZ & rz) :
 rxx(rz.xx()), rxy(rz.xy()), rxz(0.0),
 ryx(rz.yx()), ryy(rz.yy()), ryz(0.0),
 rzx(0.0), rzy(0.0), rzz(1.0) {}

inline HepRotation::~HepRotation() {}



inline HepRotation::HepRotation_row::HepRotation_row
(const HepRotation & r, int i) : rr(r), ii(i) {}

inline double HepRotation::HepRotation_row::operator [] (int jj) const {
  return rr(ii,jj);
}

inline
const HepRotation::HepRotation_row HepRotation::operator [] (int i) const {
  return HepRotation_row(*this, i);
}

inline Hep3Vector HepRotation::colX() const
    { return Hep3Vector ( rxx, ryx, rzx ); }
inline Hep3Vector HepRotation::colY() const
    { return Hep3Vector ( rxy, ryy, rzy ); }
inline Hep3Vector HepRotation::colZ() const
    { return Hep3Vector ( rxz, ryz, rzz ); }

inline Hep3Vector HepRotation::rowX() const
    { return Hep3Vector ( rxx, rxy, rxz ); }
inline Hep3Vector HepRotation::rowY() const
    { return Hep3Vector ( ryx, ryy, ryz ); }
inline Hep3Vector HepRotation::rowZ() const
    { return Hep3Vector ( rzx, rzy, rzz ); }

inline HepLorentzVector HepRotation::col1() const
    { return HepLorentzVector (colX(), 0); }
inline HepLorentzVector HepRotation::col2() const
    { return HepLorentzVector (colY(), 0); }
inline HepLorentzVector HepRotation::col3() const
    { return HepLorentzVector (colZ(), 0); }
inline HepLorentzVector HepRotation::col4() const
    { return HepLorentzVector (0,0,0,1); }
inline HepLorentzVector HepRotation::row1() const
    { return HepLorentzVector (rowX(), 0); }
inline HepLorentzVector HepRotation::row2() const
    { return HepLorentzVector (rowY(), 0); }
inline HepLorentzVector HepRotation::row3() const
    { return HepLorentzVector (rowZ(), 0); }
inline HepLorentzVector HepRotation::row4() const
    { return HepLorentzVector (0,0,0,1); }

inline double HepRotation::getPhi () const { return phi(); }
inline double HepRotation::getTheta() const { return theta(); }
inline double HepRotation::getPsi () const { return psi(); }
inline double HepRotation::getDelta() const { return delta(); }
inline Hep3Vector HepRotation::getAxis () const { return axis(); }

inline HepRotation & HepRotation::operator = (const HepRotation & m1) {
  rxx = m1.rxx;
  rxy = m1.rxy;
  rxz = m1.rxz;
  ryx = m1.ryx;
  ryy = m1.ryy;
  ryz = m1.ryz;
  rzx = m1.rzx;
  rzy = m1.rzy;
  rzz = m1.rzz;
  return *this;
}

inline HepRotation & HepRotation::set(const HepRep3x3 & m1) {
  rxx = m1.xx_;
  rxy = m1.xy_;
  rxz = m1.xz_;
  ryx = m1.yx_;
  ryy = m1.yy_;
  ryz = m1.yz_;
  rzx = m1.zx_;
  rzy = m1.zy_;
  rzz = m1.zz_;
  return *this;
}

inline HepRotation & HepRotation::set(const HepRotationX & r) {
  return (set (r.rep3x3()));
}
inline HepRotation & HepRotation::set(const HepRotationY & r) {
  return (set (r.rep3x3()));
}
inline HepRotation & HepRotation::set(const HepRotationZ & r) {
  return (set (r.rep3x3()));
}

inline HepRotation & HepRotation::operator= (const HepRotationX & r) {
  return (set (r.rep3x3()));
}
inline HepRotation & HepRotation::operator= (const HepRotationY & r) {
  return (set (r.rep3x3()));
}
inline HepRotation & HepRotation::operator= (const HepRotationZ & r) {
  return (set (r.rep3x3()));
}

inline Hep3Vector HepRotation::operator * (const Hep3Vector & p) const {
  return Hep3Vector(rxx*p.x() + rxy*p.y() + rxz*p.z(),
                    ryx*p.x() + ryy*p.y() + ryz*p.z(),
                    rzx*p.x() + rzy*p.y() + rzz*p.z());

}

inline Hep3Vector HepRotation::operator () (const Hep3Vector & p) const {
  double x = p.x();
  double y = p.y();
  double z = p.z();
  return Hep3Vector(rxx*x + rxy*y + rxz*z,
                    ryx*x + ryy*y + ryz*z,
                    rzx*x + rzy*y + rzz*z);
}

inline HepLorentzVector
HepRotation::operator () (const HepLorentzVector & w) const {
  return HepLorentzVector( operator() (w.vect()), w.t() );
}

inline HepLorentzVector HepRotation::operator *
     (const HepLorentzVector & p) const {
  return operator()(p);
}

inline HepRotation HepRotation::operator* (const HepRotation & r) const {
  return HepRotation(rxx*r.rxx + rxy*r.ryx + rxz*r.rzx,
                     rxx*r.rxy + rxy*r.ryy + rxz*r.rzy,
                     rxx*r.rxz + rxy*r.ryz + rxz*r.rzz,
                     ryx*r.rxx + ryy*r.ryx + ryz*r.rzx,
                     ryx*r.rxy + ryy*r.ryy + ryz*r.rzy,
                     ryx*r.rxz + ryy*r.ryz + ryz*r.rzz,
                     rzx*r.rxx + rzy*r.ryx + rzz*r.rzx,
                     rzx*r.rxy + rzy*r.ryy + rzz*r.rzy,
                     rzx*r.rxz + rzy*r.ryz + rzz*r.rzz );
}

inline HepRotation HepRotation::operator * (const HepRotationX & rx) const {
  double yy1 = rx.yy();
  double yz1 = rx.yz();
  double zy1 = -yz1;
  double zz1 = yy1;
  return HepRotation(
    rxx, rxy*yy1 + rxz*zy1, rxy*yz1 + rxz*zz1,
    ryx, ryy*yy1 + ryz*zy1, ryy*yz1 + ryz*zz1,
    rzx, rzy*yy1 + rzz*zy1, rzy*yz1 + rzz*zz1 );
}

inline HepRotation HepRotation::operator * (const HepRotationY & ry) const {
  double xx1 = ry.xx();
  double xz1 = ry.xz();
  double zx1 = -xz1;
  double zz1 = xx1;
  return HepRotation(
    rxx*xx1 + rxz*zx1, rxy, rxx*xz1 + rxz*zz1,
    ryx*xx1 + ryz*zx1, ryy, ryx*xz1 + ryz*zz1,
    rzx*xx1 + rzz*zx1, rzy, rzx*xz1 + rzz*zz1 );
}

inline HepRotation HepRotation::operator * (const HepRotationZ & rz) const {
  double xx1 = rz.xx();
  double xy1 = rz.xy();
  double yx1 = -xy1;
  double yy1 = xx1;
  return HepRotation(
    rxx*xx1 + rxy*yx1, rxx*xy1 + rxy*yy1, rxz,
    ryx*xx1 + ryy*yx1, ryx*xy1 + ryy*yy1, ryz,
    rzx*xx1 + rzy*yx1, rzx*xy1 + rzy*yy1, rzz );
}


inline HepRotation & HepRotation::operator *= (const HepRotation & r) {
  return *this = (*this) * (r);
}

inline HepRotation & HepRotation::operator *= (const HepRotationX & r) {
  return *this = (*this) * (r); }
inline HepRotation & HepRotation::operator *= (const HepRotationY & r) {
  return *this = (*this) * (r); }
inline HepRotation & HepRotation::operator *= (const HepRotationZ & r) {
  return *this = (*this) * (r); }

inline HepRotation & HepRotation::transform(const HepRotation & r) {
  return *this = r * (*this);
}

inline HepRotation & HepRotation::transform(const HepRotationX & r) {
  return *this = r * (*this); }
inline HepRotation & HepRotation::transform(const HepRotationY & r) {
  return *this = r * (*this); }
inline HepRotation & HepRotation::transform(const HepRotationZ & r) {
  return *this = r * (*this); }

inline HepRotation HepRotation::inverse() const {
  return HepRotation( rxx, ryx, rzx,
        rxy, ryy, rzy,
        rxz, ryz, rzz );
}

inline HepRotation inverseOf (const HepRotation & r) {
  return r.inverse();
}

inline HepRotation & HepRotation::invert() {
  return *this=inverse();
}

inline HepRotation & HepRotation::rotate
    (double ddelta, const Hep3Vector * p) {
  return rotate(ddelta, *p);
}

inline bool HepRotation::operator== ( const HepRotation & r ) const {
  return ( rxx==r.rxx && rxy==r.rxy && rxz==r.rxz &&
    ryx==r.ryx && ryy==r.ryy && ryz==r.ryz &&
    rzx==r.rzx && rzy==r.rzy && rzz==r.rzz );
}
inline bool HepRotation::operator!= ( const HepRotation & r ) const {
  return ! operator==(r);
}
inline bool HepRotation::operator< ( const HepRotation & r ) const
 { return compare(r)< 0; }
inline bool HepRotation::operator<=( const HepRotation & r ) const
 { return compare(r)<=0; }
inline bool HepRotation::operator>=( const HepRotation & r ) const
 { return compare(r)>=0; }
inline bool HepRotation::operator> ( const HepRotation & r ) const
 { return compare(r)> 0; }

inline double HepRotation::getTolerance() {
  return Hep4RotationInterface::tolerance;
}
inline double HepRotation::setTolerance(double tol) {
  return Hep4RotationInterface::setTolerance(tol);
}

inline HepRotation operator * (const HepRotationX & rx, const HepRotation & r){
  HepRep3x3 mmm = r.rep3x3();
  double c = rx.yy();
  double ss = rx.zy();
  return HepRotation ( mmm.xx_, mmm.xy_, mmm.xz_,
                        c*mmm.yx_-ss*mmm.zx_, c*mmm.yy_-ss*mmm.zy_, c*mmm.yz_-ss*mmm.zz_,
                        ss*mmm.yx_+c*mmm.zx_, ss*mmm.yy_+c*mmm.zy_, ss*mmm.yz_+c*mmm.zz_ );
}

inline HepRotation operator * (const HepRotationY & ry, const HepRotation & r){
  HepRep3x3 mmm = r.rep3x3();
  double c = ry.xx();
  double ss = ry.xz();
  return HepRotation ( c*mmm.xx_+ss*mmm.zx_, c*mmm.xy_+ss*mmm.zy_, c*mmm.xz_+ss*mmm.zz_,
                              mmm.yx_, mmm.yy_, mmm.yz_,
                       -ss*mmm.xx_+c*mmm.zx_,-ss*mmm.xy_+c*mmm.zy_,-ss*mmm.xz_+c*mmm.zz_ );
}

inline HepRotation operator * (const HepRotationZ & rz, const HepRotation & r){
  HepRep3x3 mmm = r.rep3x3();
  double c = rz.xx();
  double ss = rz.yx();
  return HepRotation ( c*mmm.xx_-ss*mmm.yx_, c*mmm.xy_-ss*mmm.yy_, c*mmm.xz_-ss*mmm.yz_,
                        ss*mmm.xx_+c*mmm.yx_, ss*mmm.xy_+c*mmm.yy_, ss*mmm.xz_+c*mmm.yz_,
                              mmm.zx_, mmm.zy_, mmm.zz_ );
}

}
# 414 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Vector/Rotation.h" 2 3
# 7 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.icc" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Point3D.h" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Point3D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/BasicVector3D.h" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/BasicVector3D.h" 3
namespace HepGeom {
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/BasicVector3D.h" 3
  template<class T> class BasicVector3D {
  protected:
    T v_[3];





    BasicVector3D() { v_[0] = 0; v_[1] = 0; v_[2] = 0; }

  public:



    enum {
      X = 0,
      Y = 1,
      Z = 2,
      NUM_COORDINATES = 3,
      SIZE = NUM_COORDINATES
    };



    BasicVector3D(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }



    BasicVector3D(const BasicVector3D<T> &) = default;



    template<typename U = T,
             typename = typename std::enable_if<!std::is_same<U,float>::value >::type>
    BasicVector3D(const BasicVector3D<float> & v) {
      v_[0] = v.x(); v_[1] = v.y(); v_[2] = v.z();
    }



    BasicVector3D(BasicVector3D<T> &&) = default;



    virtual ~BasicVector3D() = default;







    operator T * () { return v_; }



    operator const T * () const { return v_; }






    operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }







    BasicVector3D<T> & operator= (const BasicVector3D<T> &) = default;


    BasicVector3D<T> & operator= (BasicVector3D<T> &&) = default;


    BasicVector3D<T> & operator+=(const BasicVector3D<T> & v) {
      v_[0] += v.v_[0]; v_[1] += v.v_[1]; v_[2] += v.v_[2]; return *this;
    }


    BasicVector3D<T> & operator-=(const BasicVector3D<T> & v) {
      v_[0] -= v.v_[0]; v_[1] -= v.v_[1]; v_[2] -= v.v_[2]; return *this;
    }


    BasicVector3D<T> & operator*=(double a) {
      v_[0] *= a; v_[1] *= a; v_[2] *= a; return *this;
    }


    BasicVector3D<T> & operator/=(double a) {
      v_[0] /= a; v_[1] /= a; v_[2] /= a; return *this;
    }







    T operator()(int i) const { return v_[i]; }


    T operator[](int i) const { return v_[i]; }



    T & operator()(int i) { return v_[i]; }


    T & operator[](int i) { return v_[i]; }







    T x() const { return v_[0]; }


    T y() const { return v_[1]; }


    T z() const { return v_[2]; }



    void setX(T a) { v_[0] = a; }


    void setY(T a) { v_[1] = a; }


    void setZ(T a) { v_[2] = a; }



    void set(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }







    T perp2() const { return x()*x()+y()*y(); }


    T perp() const { return std::sqrt(perp2()); }


    T rho() const { return perp(); }



    void setPerp(T rh) {
      T factor = perp();
      if (factor > 0) {
 factor = rh/factor; v_[0] *= factor; v_[1] *= factor;
      }
    }







    T mag2() const { return x()*x()+y()*y()+z()*z(); }


    T mag() const { return std::sqrt(mag2()); }


    T r() const { return mag(); }


    T phi() const {
      return x() == 0 && y() == 0 ? 0 : std::atan2(y(),x());
    }


    T theta() const {
      return x() == 0 && y() == 0 && z() == 0 ? 0 : std::atan2(perp(),z());
    }


    T cosTheta() const { T ma = mag(); return ma == 0 ? 1 : z()/ma; }



    T getR() const { return r(); }


    T getPhi() const { return phi(); }


    T getTheta() const { return theta(); }



    void setMag(T ma) {
      T factor = mag();
      if (factor > 0) {
 factor = ma/factor; v_[0] *= factor; v_[1] *= factor; v_[2] *= factor;
      }
    }


    void setR(T ma) { setMag(ma); }


    void setPhi(T ph) { T xy = perp(); setX(xy*std::cos(ph)); setY(xy*std::sin(ph)); }


    void setTheta(T th) {
      T ma = mag();
      T ph = phi();
      set(ma*std::sin(th)*std::cos(ph), ma*std::sin(th)*std::sin(ph), ma*std::cos(th));
    }







    T pseudoRapidity() const;


    T eta() const { return pseudoRapidity(); }


    T getEta() const { return pseudoRapidity(); }



    void setEta(T a);







    T dot(const BasicVector3D<T> & v) const {
      return x()*v.x()+y()*v.y()+z()*v.z();
    }



    BasicVector3D<T> cross(const BasicVector3D<T> & v) const {
      return BasicVector3D<T>(y()*v.z()-v.y()*z(),
         z()*v.x()-v.z()*x(),
         x()*v.y()-v.x()*y());
    }



    T perp2(const BasicVector3D<T> & v) const {
      T tot = v.mag2(), s = dot(v);
      return tot > 0 ? mag2()-s*s/tot : mag2();
    }



    T perp(const BasicVector3D<T> & v) const {
      return std::sqrt(perp2(v));
    }



    T angle(const BasicVector3D<T> & v) const;







    BasicVector3D<T> unit() const {
      T len = mag();
      return (len > 0) ?
 BasicVector3D<T>(x()/len, y()/len, z()/len) : BasicVector3D<T>();
    }



    BasicVector3D<T> orthogonal() const {
      T dx = x() < 0 ? -x() : x();
      T dy = y() < 0 ? -y() : y();
      T dz = z() < 0 ? -z() : z();
      if (dx < dy) {
 return dx < dz ?
   BasicVector3D<T>(0,z(),-y()) : BasicVector3D<T>(y(),-x(),0);
      }else{
 return dy < dz ?
   BasicVector3D<T>(-z(),0,x()) : BasicVector3D<T>(y(),-x(),0);
      }
    }







    BasicVector3D<T> & rotateX(T a);


    BasicVector3D<T> & rotateY(T a);


    BasicVector3D<T> & rotateZ(T a);


    BasicVector3D<T> & rotate(T a, const BasicVector3D<T> & v);
  };
# 361 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/BasicVector3D.h" 3
  std::ostream &
  operator<<(std::ostream &, const BasicVector3D<float> &);





  std::istream &
  operator>>(std::istream &, BasicVector3D<float> &);





  inline BasicVector3D<float>
  operator+(const BasicVector3D<float> & v) { return v; }





  inline BasicVector3D<float>
  operator+(const BasicVector3D<float> & a, const BasicVector3D<float> & b) {
    return BasicVector3D<float>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
  }





  inline BasicVector3D<float>
  operator-(const BasicVector3D<float> & v) {
    return BasicVector3D<float>(-v.x(), -v.y(), -v.z());
  }





  inline BasicVector3D<float>
  operator-(const BasicVector3D<float> & a, const BasicVector3D<float> & b) {
    return BasicVector3D<float>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
  }





  inline BasicVector3D<float>
  operator*(const BasicVector3D<float> & v, double a) {
    return BasicVector3D<float>(v.x()*static_cast<float>(a), v.y()*static_cast<float>(a), v.z()*static_cast<float>(a));
  }





  inline float
  operator*(const BasicVector3D<float> & a, const BasicVector3D<float> & b) {
    return a.dot(b);
  }





  inline BasicVector3D<float>
  operator*(double a, const BasicVector3D<float> & v) {
    return BasicVector3D<float>(static_cast<float>(a)*v.x(), static_cast<float>(a)*v.y(), static_cast<float>(a)*v.z());
  }





  inline BasicVector3D<float>
  operator/(const BasicVector3D<float> & v, double a) {
    return BasicVector3D<float>(v.x()/static_cast<float>(a), v.y()/static_cast<float>(a), v.z()/static_cast<float>(a));
  }





  inline bool
  operator==(const BasicVector3D<float> & a, const BasicVector3D<float> & b) {
    return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
  }





  inline bool
  operator!=(const BasicVector3D<float> & a, const BasicVector3D<float> & b) {
    return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
  }
# 469 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/BasicVector3D.h" 3
  std::ostream &
  operator<<(std::ostream &, const BasicVector3D<double> &);





  std::istream &
  operator>>(std::istream &, BasicVector3D<double> &);





  inline BasicVector3D<double>
  operator+(const BasicVector3D<double> & v) { return v; }





  inline BasicVector3D<double>
  operator+(const BasicVector3D<double> & a,const BasicVector3D<double> & b) {
    return BasicVector3D<double>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
  }





  inline BasicVector3D<double>
  operator-(const BasicVector3D<double> & v) {
    return BasicVector3D<double>(-v.x(), -v.y(), -v.z());
  }





  inline BasicVector3D<double>
  operator-(const BasicVector3D<double> & a,const BasicVector3D<double> & b) {
    return BasicVector3D<double>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
  }





  inline BasicVector3D<double>
  operator*(const BasicVector3D<double> & v, double a) {
    return BasicVector3D<double>(v.x()*a, v.y()*a, v.z()*a);
  }





  inline double
  operator*(const BasicVector3D<double> & a,const BasicVector3D<double> & b) {
    return a.dot(b);
  }





  inline BasicVector3D<double>
  operator*(double a, const BasicVector3D<double> & v) {
    return BasicVector3D<double>(a*v.x(), a*v.y(), a*v.z());
  }





  inline BasicVector3D<double>
  operator/(const BasicVector3D<double> & v, double a) {
    return BasicVector3D<double>(v.x()/a, v.y()/a, v.z()/a);
  }





  inline bool
  operator==(const BasicVector3D<double> & a, const BasicVector3D<double> & b)
  {
    return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
  }





  inline bool
  operator!=(const BasicVector3D<double> & a, const BasicVector3D<double> & b)
  {
    return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
  }
}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Point3D.h" 2 3

namespace HepGeom {

  class Transform3D;
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Point3D.h" 3
  template<class T>
  class Point3D : public BasicVector3D<T> {};







  template<>
  class Point3D<float> : public BasicVector3D<float> {
  public:


    Point3D() = default;



    Point3D(float x1, float y1, float z1) : BasicVector3D<float>(x1,y1,z1) {}



    explicit Point3D(const float * a)
      : BasicVector3D<float>(a[0],a[1],a[2]) {}



    Point3D(const Point3D<float> &) = default;



    Point3D(Point3D<float> &&) = default;



    Point3D(const BasicVector3D<float> & v) : BasicVector3D<float>(v) {}



    ~Point3D() = default;



    Point3D<float> & operator=(const Point3D<float> &) = default;



    Point3D<float> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<float>::operator=(v);
      return *this;
    }



    Point3D<float> & operator=(Point3D<float> &&) = default;



    float distance2() const { return mag2(); }



    float distance2(const Point3D<float> & p) const {
      float dx = p.x()-x(), dy = p.y()-y(), dz = p.z()-z();
      return dx*dx + dy*dy + dz*dz;
    }



    float distance() const { return std::sqrt(distance2()); }



    float distance(const Point3D<float> & p) const {
      return std::sqrt(distance2(p));
    }



    Point3D<float> & transform(const Transform3D & m);
  };





  Point3D<float>
  operator*(const Transform3D & m, const Point3D<float> & p);







  template<>
  class Point3D<double> : public BasicVector3D<double> {
  public:


    Point3D() = default;



    Point3D(double x1, double y1, double z1) : BasicVector3D<double>(x1,y1,z1) {}



    explicit Point3D(const float * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    explicit Point3D(const double * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    Point3D(const Point3D<double> &) = default;



    Point3D(Point3D<double> &&) = default;



    Point3D(const BasicVector3D<float> & v) : BasicVector3D<double>(v) {}



    Point3D(const BasicVector3D<double> & v) : BasicVector3D<double>(v) {}



    ~Point3D() = default;






    Point3D(const CLHEP::Hep3Vector & v)
      : BasicVector3D<double>(v.x(),v.y(),v.z()) {}






    operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }



    Point3D<double> & operator=(const Point3D<double> &) = default;



    Point3D<double> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Point3D<double> & operator=(const BasicVector3D<double> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Point3D<double> & operator=(Point3D<double> &&) = default;



    double distance2() const { return mag2(); }



    double distance2(const Point3D<double> & p) const {
      double dx = p.x()-x(), dy = p.y()-y(), dz = p.z()-z();
      return dx*dx + dy*dy + dz*dz;
    }



    double distance() const { return std::sqrt(distance2()); }



    double distance(const Point3D<double> & p) const {
      return std::sqrt(distance2(p));
    }



    Point3D<double> & transform(const Transform3D & m);
  };





  Point3D<double>
  operator*(const Transform3D & m, const Point3D<double> & p);

}
# 8 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.icc" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Vector3D.h" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Vector3D.h" 3
namespace HepGeom {

  class Transform3D;
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Vector3D.h" 3
  template<class T>
  class Vector3D : public BasicVector3D<T> {};







  template<>
  class Vector3D<float> : public BasicVector3D<float> {
  public:


    Vector3D() = default;



    Vector3D(float x1, float y1, float z1) : BasicVector3D<float>(x1,y1,z1) {}



    explicit Vector3D(const float * a)
      : BasicVector3D<float>(a[0],a[1],a[2]) {}



    Vector3D(const Vector3D<float> &) = default;



    Vector3D(Vector3D<float> &&) = default;



    Vector3D(const BasicVector3D<float> & v) : BasicVector3D<float>(v) {}



    ~Vector3D() = default;



    Vector3D<float> & operator=(const Vector3D<float> &) = default;



    Vector3D<float> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<float>::operator=(v);
      return *this;
    }



    Vector3D<float> & operator=(Vector3D<float> &&) = default;



    Vector3D<float> & transform(const Transform3D & m);
  };





  Vector3D<float>
  operator*(const Transform3D & m, const Vector3D<float> & v);







  template<>
  class Vector3D<double> : public BasicVector3D<double> {
  public:


    Vector3D() = default;



    Vector3D(double x1, double y1, double z1) : BasicVector3D<double>(x1,y1,z1) {}



    explicit Vector3D(const float * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    explicit Vector3D(const double * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    Vector3D(const Vector3D<double> &) = default;



    Vector3D(Vector3D<double> &&) = default;



    Vector3D(const BasicVector3D<float> & v) : BasicVector3D<double>(v) {}



    Vector3D(const BasicVector3D<double> & v) : BasicVector3D<double>(v) {}



    ~Vector3D() = default;






    Vector3D(const CLHEP::Hep3Vector & v)
      : BasicVector3D<double>(v.x(),v.y(),v.z()) {}






    operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }



    Vector3D<double> & operator=(const Vector3D<double> &) = default;



    Vector3D<double> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Vector3D<double> & operator=(const BasicVector3D<double> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Vector3D<double> & operator=(Vector3D<double> &&) = default;



    Vector3D<double> & transform(const Transform3D & m);
  };





  Vector3D<double>
  operator*(const Transform3D & m, const Vector3D<double> & v);

}
# 9 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.icc" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Normal3D.h" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Normal3D.h" 3
namespace HepGeom {

  class Transform3D;
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Normal3D.h" 3
  template<class T>
  class Normal3D : public BasicVector3D<T> {};







  template<>
  class Normal3D<float> : public BasicVector3D<float> {
  public:


    Normal3D() = default;



    Normal3D(float x1, float y1, float z1) : BasicVector3D<float>(x1,y1,z1) {}



    explicit Normal3D(const float * a)
      : BasicVector3D<float>(a[0],a[1],a[2]) {}



    Normal3D(const Normal3D<float> &) = default;



    Normal3D(Normal3D<float> &&) = default;



    Normal3D(const BasicVector3D<float> & v) : BasicVector3D<float>(v) {}



    ~Normal3D() = default;



    Normal3D<float> & operator=(const Normal3D<float> &) = default;



    Normal3D<float> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<float>::operator=(v);
      return *this;
    }



    Normal3D<float> & operator=(Normal3D<float> &&) = default;



    Normal3D<float> & transform(const Transform3D & m);
  };





  Normal3D<float>
  operator*(const Transform3D & m, const Normal3D<float> & n);







  template<>
  class Normal3D<double> : public BasicVector3D<double> {
  public:


    Normal3D() = default;



    Normal3D(double x1, double y1, double z1) : BasicVector3D<double>(x1,y1,z1) {}



    explicit Normal3D(const float * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    explicit Normal3D(const double * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}



    Normal3D(const Normal3D<double> &) = default;



    Normal3D(Normal3D<double> &&) = default;



    Normal3D(const BasicVector3D<float> & v) : BasicVector3D<double>(v) {}



    Normal3D(const BasicVector3D<double> & v) : BasicVector3D<double>(v) {}



    ~Normal3D() = default;






    Normal3D(const CLHEP::Hep3Vector & v)
      : BasicVector3D<double>(v.x(),v.y(),v.z()) {}






    operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }



    Normal3D<double> & operator=(const Normal3D<double> &) = default;



    Normal3D<double> & operator=(const BasicVector3D<float> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Normal3D<double> & operator=(const BasicVector3D<double> & v) {
      this->BasicVector3D<double>::operator=(v);
      return *this;
    }



    Normal3D<double> & operator=(Normal3D<double> &&) = default;



    Normal3D<double> & transform(const Transform3D & m);
  };





  Normal3D<double>
  operator*(const Transform3D & m, const Normal3D<double> & n);

}
# 10 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.icc" 2 3

namespace HepGeom {



inline
Transform3D::Transform3D_row::Transform3D_row
(const Transform3D & r, int i) : rr(r), ii(i) {}

inline
double Transform3D::Transform3D_row::operator[](int jj) const {
  return rr(ii,jj);
}

inline
const Transform3D::Transform3D_row Transform3D::operator[](int i) const {
  return Transform3D_row(*this, i);
}

inline
Transform3D::Transform3D(const CLHEP::HepRotation & mt, const CLHEP::Hep3Vector & v) {
  xx_= mt.xx(); xy_= mt.xy(); xz_= mt.xz();
  yx_= mt.yx(); yy_= mt.yy(); yz_= mt.yz();
  zx_= mt.zx(); zy_= mt.zy(); zz_= mt.zz();
  dx_= v.x(); dy_= v.y(); dz_= v.z();
}

inline
CLHEP::HepRotation
Transform3D::getRotation() const {
  CLHEP::HepRotation mt;
  return mt.rotateAxes(CLHEP::Hep3Vector(xx_,yx_,zx_),
                       CLHEP::Hep3Vector(xy_,yy_,zy_),
                       CLHEP::Hep3Vector(xz_,yz_,zz_));
}

inline
CLHEP::Hep3Vector
Transform3D::getTranslation() const {
  return CLHEP::Hep3Vector(dx_,dy_,dz_);
}



inline
Rotate3D::Rotate3D(const CLHEP::HepRotation & mt) {
  xx_= mt.xx(); xy_= mt.xy(); xz_= mt.xz();
  yx_= mt.yx(); yy_= mt.yy(); yz_= mt.yz();
  zx_= mt.zx(); zy_= mt.zy(); zz_= mt.zz();
  dx_= 0; dy_= 0; dz_= 0;
}

inline
Rotate3D::Rotate3D(double a, const Vector3D<double> & v) {
  *this =
    Rotate3D(a, Point3D<double>(0,0,0), Point3D<double>(v.x(),v.y(),v.z()));
}

inline
Rotate3D::Rotate3D(const Point3D<double> & fr1, const Point3D<double> & fr2,
     const Point3D<double> & to1, const Point3D<double> & to2)
  : Transform3D(Point3D<double>(0,0,0),fr1,fr2,
  Point3D<double>(0,0,0),to1,to2) {}



inline
Translate3D::Translate3D(const CLHEP::Hep3Vector & v)
  : Transform3D(1,0,0,v.x(), 0,1,0,v.y(), 0,0,1,v.z()) {}



inline
Reflect3D::Reflect3D(const Normal3D<double> & n, const Point3D<double> & p) {
  *this = Reflect3D(n.x(), n.y(), n.z(), -n*p);
}

}
# 838 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP/Geometry/Transform3D.h" 2 3
# 13 "include/klm/bklm/geometry/Module.h" 2




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 1 3
# 71 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Alloc = void>
    struct _UninitDestroyGuard
    {
      constexpr
      explicit
      _UninitDestroyGuard(_ForwardIterator& __first, _Alloc& __a)
      : _M_first(__first), _M_cur(__builtin_addressof(__first)), _M_alloc(__a)
      { }

      constexpr
      ~_UninitDestroyGuard()
      {
 if (__builtin_expect(_M_cur != 0, 0))
   std::_Destroy(_M_first, *_M_cur, _M_alloc);
      }

      constexpr
      void release() { _M_cur = 0; }

    private:
      _ForwardIterator const _M_first;
      _ForwardIterator* _M_cur;
      _Alloc& _M_alloc;

      _UninitDestroyGuard(const _UninitDestroyGuard&);
    };

  template<typename _ForwardIterator>
    struct _UninitDestroyGuard<_ForwardIterator, void>
    {
      constexpr
      explicit
      _UninitDestroyGuard(_ForwardIterator& __first)
      : _M_first(__first), _M_cur(__builtin_addressof(__first))
      { }

      constexpr
      ~_UninitDestroyGuard()
      {
 if (__builtin_expect(_M_cur != 0, 0))
   std::_Destroy(_M_first, *_M_cur);
      }

      constexpr
      void release() { _M_cur = 0; }

      _ForwardIterator const _M_first;
      _ForwardIterator* _M_cur;

    private:
      _UninitDestroyGuard(const _UninitDestroyGuard&);
    };



  template<typename _InputIterator, typename _Sentinel,
    typename _ForwardIterator>
    constexpr
    _ForwardIterator
    __do_uninit_copy(_InputIterator __first, _Sentinel __last,
       _ForwardIterator __result)
    {
      _UninitDestroyGuard<_ForwardIterator> __guard(__result);
      for (; __first != __last; ++__first, (void)++__result)
 std::_Construct(std::__addressof(*__result), *__first);
      __guard.release();
      return __result;
    }
# 217 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
# 228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>

    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
# 256 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
      using _Dest = decltype(std::__niter_base(__result));
      using _Src = decltype(std::__niter_base(__first));
      using _ValT = typename iterator_traits<_ForwardIterator>::value_type;






      if constexpr (!__is_trivially_constructible(_ValT, decltype(*__first)))
 return std::__do_uninit_copy(__first, __last, __result);
      else if constexpr (__memcpyable<_Dest, _Src>::__value)
 {
   ptrdiff_t __n = __last - __first;
   if (__n > 0) [[__likely__]]
     {
       using _ValT = typename remove_pointer<_Src>::type;
       __builtin_memcpy(std::__niter_base(__result),
          std::__niter_base(__first),
          __n * sizeof(_ValT));
       __result += __n;
     }
   return __result;
 }

      else if constexpr (contiguous_iterator<_ForwardIterator>
      && contiguous_iterator<_InputIterator>)
 {
   using _DestPtr = decltype(std::to_address(__result));
   using _SrcPtr = decltype(std::to_address(__first));
   if constexpr (__memcpyable<_DestPtr, _SrcPtr>::__value)
     {
       if (auto __n = __last - __first; __n > 0) [[likely]]
  {
    void* __dest = std::to_address(__result);
    const void* __src = std::to_address(__first);
    size_t __nbytes = __n * sizeof(remove_pointer_t<_DestPtr>);
    __builtin_memcpy(__dest, __src, __nbytes);
    __result += __n;
  }
       return __result;
     }
   else
     return std::__do_uninit_copy(__first, __last, __result);
 }

      else
 return std::__do_uninit_copy(__first, __last, __result);
# 317 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
    }
#pragma GCC diagnostic pop




  template<typename _ForwardIterator, typename _Tp>
    constexpr void
    __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __x)
    {
      _UninitDestroyGuard<_ForwardIterator> __guard(__first);
      for (; __first != __last; ++__first)
 std::_Construct(std::__addressof(*__first), __x);
      __guard.release();
    }
# 389 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>

    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
# 404 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"





      if constexpr (__is_byte<_ValueType>::__value)
 if constexpr (is_same<_ValueType, _Tp>::value
   || is_integral<_Tp>::value)
   {
     using _BasePtr = decltype(std::__niter_base(__first));
     if constexpr (is_pointer<_BasePtr>::value)
       {
  void* __dest = std::__niter_base(__first);
  ptrdiff_t __n = __last - __first;
  if (__n > 0) [[__likely__]]
    __builtin_memset(__dest, (unsigned char)__x, __n);
  return;
       }

     else if constexpr (contiguous_iterator<_ForwardIterator>)
       {
  auto __dest = std::to_address(__first);
  auto __n = __last - __first;
  if (__n > 0) [[__likely__]]
    __builtin_memset(__dest, (unsigned char)__x, __n);
  return;
       }

   }
      std::__do_uninit_fill(__first, __last, __x);
#pragma GCC diagnostic pop






    }




  template<typename _ForwardIterator, typename _Size, typename _Tp>
    constexpr
    _ForwardIterator
    __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      _UninitDestroyGuard<_ForwardIterator> __guard(__first);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      if constexpr (is_integral<_Size>::value)

 do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
      else if constexpr (is_floating_point<_Size>::value)

 do { if (std::__is_constant_evaluated() && !bool(__n >= 0 && static_cast<size_t>(__n) == __n)) std::__glibcxx_assert_fail(); } while (false);
#pragma GCC diagnostic pop

      for (; __n--; ++__first)
 std::_Construct(std::__addressof(*__first), __x);
      __guard.release();
      return __first;
    }
# 510 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
# 523 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;







      if constexpr (__is_byte<_ValueType>::__value)
 if constexpr (is_integral<_Tp>::value)
   if constexpr (is_integral<_Size>::value)
     {
       using _BasePtr = decltype(std::__niter_base(__first));
       if constexpr (is_pointer<_BasePtr>::value)
  {
    void* __dest = std::__niter_base(__first);
    if (__n > 0) [[__likely__]]
      {
        __builtin_memset(__dest, (unsigned char)__x, __n);
        __first += __n;
      }
    return __first;
  }

       else if constexpr (contiguous_iterator<_ForwardIterator>)
  {
    auto __dest = std::to_address(__first);
    if (__n > 0) [[__likely__]]
      {
        __builtin_memset(__dest, (unsigned char)__x, __n);
        __first += __n;
      }
    return __first;
  }

     }
      return std::__do_uninit_fill_n(__first, __n, __x);
# 580 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
    }
#pragma GCC diagnostic pop
# 591 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _Sentinel,
    typename _ForwardIterator, typename _Allocator>
    constexpr
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _Sentinel __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      _UninitDestroyGuard<_ForwardIterator, _Allocator>
 __guard(__result, __alloc);

      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __first != __last; ++__first, (void)++__result)
 __traits::construct(__alloc, std::__addressof(*__result), *__first);
      __guard.release();
      return __result;
    }


  template<typename _InputIterator, typename _Sentinel,
    typename _ForwardIterator, typename _Tp>
    constexpr
    inline _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _Sentinel __last,
      _ForwardIterator __result, allocator<_Tp>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_copy(std::move(__first), __last, __result);



      if constexpr (!is_same_v<_InputIterator, _Sentinel>)
 {


   if constexpr (sized_sentinel_for<_Sentinel, _InputIterator>
     && random_access_iterator<_InputIterator>)
     return std::uninitialized_copy(__first,
        __first + (__last - __first),
        __result);
   else
     return std::__do_uninit_copy(std::move(__first), __last, __result);
 }
      else
 return std::uninitialized_copy(std::move(__first), __last, __result);



    }


  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    constexpr
    inline _ForwardIterator
    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
      std::make_move_iterator(__last),
      __result, __alloc);
    }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    constexpr
    inline _ForwardIterator
    __uninitialized_move_if_noexcept_a(_InputIterator __first,
           _InputIterator __last,
           _ForwardIterator __result,
           _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a
 (std::__make_move_if_noexcept_iterator(__first),
  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
    constexpr
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator& __alloc)
    {
      _UninitDestroyGuard<_ForwardIterator, _Allocator>
 __guard(__first, __alloc);

      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __first != __last; ++__first)
 __traits::construct(__alloc, std::__addressof(*__first), __x);

      __guard.release();
    }


  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
    constexpr
    inline void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, allocator<_Tp2>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_fill(__first, __last, __x);

      std::uninitialized_fill(__first, __last, __x);
    }


  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Allocator>
     constexpr
    _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, _Allocator& __alloc)
    {
      _UninitDestroyGuard<_ForwardIterator, _Allocator>
 __guard(__first, __alloc);
      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __n > 0; --__n, (void) ++__first)
 __traits::construct(__alloc, std::__addressof(*__first), __x);
      __guard.release();
      return __first;
    }


  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Tp2>
    constexpr
    inline _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, allocator<_Tp2>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_fill_n(__first, __n, __x);

      return std::uninitialized_fill_n(__first, __n, __x);
    }
# 740 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result,
        __alloc);
      __result = __mid;
      __result = std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
      __guard.release();
      return __result;
    }





  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);
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result,
        __alloc);
      __result = __mid;
      __result = std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
      __guard.release();
      return __result;
    }




  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);
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__result,
        __alloc);
      __result = __mid;
      __result = std::__uninitialized_move_a(__first, __last, __mid, __alloc);
      __guard.release();
      return __result;
    }




  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);
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first2,
        __alloc);
      __first2 = __mid2;
      std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
      __guard.release();
    }
# 832 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template<bool _TrivialValueType>
    struct __uninitialized_default_1
    {
      template<typename _ForwardIterator>

        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   _UninitDestroyGuard<_ForwardIterator> __guard(__first);
   for (; __first != __last; ++__first)
     std::_Construct(std::__addressof(*__first));
   __guard.release();
 }
    };

  template<>
    struct __uninitialized_default_1<true>
    {
      template<typename _ForwardIterator>

        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   if (__first == __last)
     return;

   typename iterator_traits<_ForwardIterator>::value_type* __val
     = std::__addressof(*__first);
   std::_Construct(__val);
   if (++__first != __last)
     std::fill(__first, __last, *__val);
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_n_1
    {
      template<typename _ForwardIterator, typename _Size>
 constexpr
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   _UninitDestroyGuard<_ForwardIterator> __guard(__first);
   for (; __n > 0; --__n, (void) ++__first)
     std::_Construct(std::__addressof(*__first));
   __guard.release();
   return __first;
 }
    };

  template<>
    struct __uninitialized_default_n_1<true>
    {
      template<typename _ForwardIterator, typename _Size>
 constexpr
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   if (__n > 0)
     {
       typename iterator_traits<_ForwardIterator>::value_type* __val
  = std::__addressof(*__first);
       std::_Construct(__val);
       ++__first;
       __first = std::fill_n(__first, __n - 1, *__val);
     }
   return __first;
 }
    };



  template<typename _ForwardIterator>
    constexpr
    inline void
    __uninitialized_default(_ForwardIterator __first,
       _ForwardIterator __last)
    {

      if (std::is_constant_evaluated())
 return __uninitialized_default_1<false>::
   __uninit_default(__first, __last);


      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      const bool __assignable = is_copy_assignable<_ValueType>::value;

      std::__uninitialized_default_1<__is_trivial(_ValueType)
         && __assignable>::
 __uninit_default(__first, __last);
    }



  template<typename _ForwardIterator, typename _Size>
    constexpr
    inline _ForwardIterator
    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
    {

      if (std::is_constant_evaluated())
 return __uninitialized_default_n_1<false>::
   __uninit_default_n(__first, __n);


      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      constexpr bool __can_fill
 = __and_<is_integral<_Size>, is_copy_assignable<_ValueType>>::value;

      return __uninitialized_default_n_1<__is_trivial(_ValueType)
      && __can_fill>::
 __uninit_default_n(__first, __n);
    }





  template<typename _ForwardIterator, typename _Allocator>
    void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         _Allocator& __alloc)
    {
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first,
        __alloc);
      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __first != __last; ++__first)
 __traits::construct(__alloc, std::__addressof(*__first));
      __guard.release();
    }


  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         allocator<_Tp>&)
    { std::__uninitialized_default(__first, __last); }





  template<typename _ForwardIterator, typename _Size, typename _Allocator>
    constexpr _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    _Allocator& __alloc)
    {
      _UninitDestroyGuard<_ForwardIterator, _Allocator> __guard(__first,
        __alloc);
      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __n > 0; --__n, (void) ++__first)
 __traits::construct(__alloc, std::__addressof(*__first));
      __guard.release();
      return __first;
    }




  template<typename _ForwardIterator, typename _Size, typename _Tp>
    constexpr
    inline _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    allocator<_Tp>&)
    { return std::__uninitialized_default_n(__first, __n); }


  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_1
    {
      template<typename _ForwardIterator>

 static void
 __uninit_default_novalue(_ForwardIterator __first,
     _ForwardIterator __last)
 {
   _UninitDestroyGuard<_ForwardIterator> __guard(__first);
   for (; __first != __last; ++__first)
     std::_Construct_novalue(std::__addressof(*__first));
   __guard.release();
 }
    };

  template<>
    struct __uninitialized_default_novalue_1<true>
    {
      template<typename _ForwardIterator>

        static void
        __uninit_default_novalue(_ForwardIterator, _ForwardIterator)
 {
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_n_1
    {
      template<typename _ForwardIterator, typename _Size>

 static _ForwardIterator
 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
 {
   _UninitDestroyGuard<_ForwardIterator> __guard(__first);
   for (; __n > 0; --__n, (void) ++__first)
     std::_Construct_novalue(std::__addressof(*__first));
   __guard.release();
   return __first;
 }
    };

  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)
    {
      _UninitDestroyGuard<_ForwardIterator> __guard(__result);
      for (; __n > 0; --__n, (void) ++__first, ++__result)
 std::_Construct(std::__addressof(*__result), *__first);
      __guard.release();
      return __result;
    }

  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)
    {
      _UninitDestroyGuard<_ForwardIterator> __guard(__result);
      for (; __n > 0; --__n, (void) ++__first, ++__result)
 std::_Construct(std::__addressof(*__result), *__first);
      __guard.release();
      return {__first, __result};
    }

  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};
    }
# 1151 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
    }
# 1180 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator>

    inline void
    uninitialized_default_construct(_ForwardIterator __first,
        _ForwardIterator __last)
    {
      std::__uninitialized_default_novalue(__first, __last);
    }
# 1196 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator, typename _Size>

    inline _ForwardIterator
    uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
    {
      return std::__uninitialized_default_novalue_n(__first, __count);
    }







  template <typename _ForwardIterator>

    inline void
    uninitialized_value_construct(_ForwardIterator __first,
      _ForwardIterator __last)
    {
      return std::__uninitialized_default(__first, __last);
    }
# 1226 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator, typename _Size>

    inline _ForwardIterator
    uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
    {
      return std::__uninitialized_default_n(__first, __count);
    }
# 1242 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }
# 1261 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_uninitialized.h" 3
  template <typename _InputIterator, typename _Size, typename _ForwardIterator>

    inline pair<_InputIterator, _ForwardIterator>
    uninitialized_move_n(_InputIterator __first, _Size __count,
    _ForwardIterator __result)
    {
      auto __res = std::__uninitialized_copy_n_pair
 (std::make_move_iterator(__first),
  __count, __result);
      return {__res.first.base(), __res.second};
    }





  template<typename _Tp, typename _Up, typename _Allocator>
    constexpr
    inline void
    __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
   _Allocator& __alloc)
    noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
    __dest, std::move(*__orig)))
      && noexcept(std::allocator_traits<_Allocator>::destroy(
       __alloc, std::__addressof(*__orig))))
    {
      typedef std::allocator_traits<_Allocator> __traits;
      __traits::construct(__alloc, __dest, std::move(*__orig));
      __traits::destroy(__alloc, std::__addressof(*__orig));
    }



  template<typename _Tp, typename = void>
    struct __is_bitwise_relocatable
    : __bool_constant<__is_trivial(_Tp)>
    { };

  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    constexpr
    inline _ForwardIterator
    __relocate_a_1(_InputIterator __first, _InputIterator __last,
     _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
            std::addressof(*__first),
            __alloc)))
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;
      static_assert(std::is_same<_ValueType, _ValueType2>::value,
   "relocation is only possible for values of the same type");
      _ForwardIterator __cur = __result;
      for (; __first != __last; ++__first, (void)++__cur)
 std::__relocate_object_a(std::__addressof(*__cur),
     std::__addressof(*__first), __alloc);
      return __cur;
    }


  template <typename _Tp, typename _Up>
    constexpr
    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
    __relocate_a_1(_Tp* __first, _Tp* __last,
     _Tp* __result,
     [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept
    {
      ptrdiff_t __count = __last - __first;
      if (__count > 0)
 {

   if (std::is_constant_evaluated())
     {


       __gnu_cxx::__normal_iterator<_Tp*, void> __out(__result);
       __out = std::__relocate_a_1(__first, __last, __out, __alloc);
       return __out.base();
     }

   __builtin_memcpy(__result, __first, __count * sizeof(_Tp));
 }
      return __result + __count;
    }


  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    constexpr
    inline _ForwardIterator
    __relocate_a(_InputIterator __first, _InputIterator __last,
   _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
         std::__niter_base(__last),
         std::__niter_base(__result), __alloc)))
    {
      return std::__relocate_a_1(std::__niter_base(__first),
     std::__niter_base(__last),
     std::__niter_base(__result), __alloc);
    }







}
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 1 3
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Tp>::other _Tp_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
        pointer;

      struct _Vector_impl_data
      {
 pointer _M_start;
 pointer _M_finish;
 pointer _M_end_of_storage;

 constexpr
 _Vector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 constexpr
 _Vector_impl_data(_Vector_impl_data&& __x) noexcept
 : _M_start(__x._M_start), _M_finish(__x._M_finish),
   _M_end_of_storage(__x._M_end_of_storage)
 { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); }


 constexpr
 void
 _M_copy_data(_Vector_impl_data const& __x) noexcept
 {
   _M_start = __x._M_start;
   _M_finish = __x._M_finish;
   _M_end_of_storage = __x._M_end_of_storage;
 }

 constexpr
 void
 _M_swap_data(_Vector_impl_data& __x) noexcept
 {


   _Vector_impl_data __tmp;
   __tmp._M_copy_data(*this);
   _M_copy_data(__x);
   __x._M_copy_data(__tmp);
 }
      };

      struct _Vector_impl
 : public _Tp_alloc_type, public _Vector_impl_data
      {
 constexpr
 _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)


 requires is_default_constructible_v<_Tp_alloc_type>

 : _Tp_alloc_type()
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type const& __a) noexcept
 : _Tp_alloc_type(__a)
 { }




 constexpr
 _Vector_impl(_Vector_impl&& __x) noexcept
 : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type&& __a) noexcept
 : _Tp_alloc_type(std::move(__a))
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
 : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
 { }
# 300 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      };

    public:
      typedef _Alloc allocator_type;

      constexpr
      _Tp_alloc_type&
      _M_get_Tp_allocator() noexcept
      { return this->_M_impl; }

      constexpr
      const _Tp_alloc_type&
      _M_get_Tp_allocator() const noexcept
      { return this->_M_impl; }

      constexpr
      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Tp_allocator()); }


      _Vector_base() = default;




      constexpr
      _Vector_base(const allocator_type& __a) noexcept
      : _M_impl(__a) { }



      constexpr
      _Vector_base(size_t __n)
      : _M_impl()
      { _M_create_storage(__n); }


      constexpr
      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      { _M_create_storage(__n); }


      _Vector_base(_Vector_base&&) = default;



      constexpr
      _Vector_base(_Tp_alloc_type&& __a) noexcept
      : _M_impl(std::move(__a)) { }

      constexpr
      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
      : _M_impl(__a)
      {
 if (__x.get_allocator() == __a)
   this->_M_impl._M_swap_data(__x._M_impl);
 else
   {
     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
     _M_create_storage(__n);
   }
      }


      constexpr
      _Vector_base(const allocator_type& __a, _Vector_base&& __x)
      : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
      { }


      constexpr
      ~_Vector_base() noexcept
      {
 _M_deallocate(_M_impl._M_start,
        _M_impl._M_end_of_storage - _M_impl._M_start);
      }

    public:
      _Vector_impl _M_impl;

      constexpr
      pointer
      _M_allocate(size_t __n)
      {
 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
 return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
      }

      constexpr
      void
      _M_deallocate(pointer __p, size_t __n)
      {
 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
 if (__p)
   _Tr::deallocate(_M_impl, __p, __n);
      }

    protected:

      constexpr
      void
      _M_create_storage(size_t __n)
      {
 this->_M_impl._M_start = this->_M_allocate(__n);
 this->_M_impl._M_finish = this->_M_impl._M_start;
 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
      }
# 432 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
    };
# 457 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
# 470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
   "std::vector must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
   "std::vector must have the same value_type as its allocator");



      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;

    public:
      typedef _Tp value_type;
      typedef typename _Base::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    private:

      static constexpr bool
      _S_nothrow_relocate(true_type)
      {
 return noexcept(std::__relocate_a(std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<_Tp_alloc_type&>()));
      }

      static constexpr bool
      _S_nothrow_relocate(false_type)
      { return false; }

      static constexpr bool
      _S_use_relocate()
      {



 return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
      }

      static pointer
      _S_do_relocate(pointer __first, pointer __last, pointer __result,
       _Tp_alloc_type& __alloc, true_type) noexcept
      {
 return std::__relocate_a(__first, __last, __result, __alloc);
      }

      static pointer
      _S_do_relocate(pointer, pointer, pointer __result,
       _Tp_alloc_type&, false_type) noexcept
      { return __result; }

      static constexpr pointer
      _S_relocate(pointer __first, pointer __last, pointer __result,
    _Tp_alloc_type& __alloc) noexcept
      {


 return std::__relocate_a(__first, __last, __result, __alloc);




      }


    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;

    public:







      vector() = default;
# 570 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      explicit
      constexpr
      vector(const allocator_type& __a) noexcept
      : _Base(__a) { }
# 584 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      explicit
      constexpr
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : _Base(_S_check_init_len(__n, __a), __a)
      { _M_default_initialize(__n); }
# 598 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector(size_type __n, const value_type& __value,
      const allocator_type& __a = allocator_type())
      : _Base(_S_check_init_len(__n, __a), __a)
      { _M_fill_initialize(__n, __value); }
# 630 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector(const vector& __x)
      : _Base(__x.size(),
 _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
      {
 this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }
# 650 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      vector(vector&&) noexcept = default;


      constexpr
      vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
      : _Base(__x.size(), __a)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }

    private:
      constexpr
      vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
      : _Base(__m, std::move(__rv))
      { }

      constexpr
      vector(vector&& __rv, const allocator_type& __m, false_type)
      : _Base(__m)
      {
 if (__rv.get_allocator() == __m)
   this->_M_impl._M_swap_data(__rv._M_impl);
 else if (!__rv.empty())
   {
     this->_M_create_storage(__rv.size());
     this->_M_impl._M_finish =
       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
       this->_M_impl._M_start,
       _M_get_Tp_allocator());
     __rv.clear();
   }
      }

    public:

      constexpr
      vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
      noexcept( noexcept(
 vector(std::declval<vector&&>(), std::declval<const allocator_type&>(),
        std::declval<typename _Alloc_traits::is_always_equal>())) )
      : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{})
      { }
# 707 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector(initializer_list<value_type> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_range_initialize_n(__l.begin(), __l.end(), __l.size());
      }
# 733 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 {

   if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>
     || forward_iterator<_InputIterator>)
     {
       const auto __n
  = static_cast<size_type>(ranges::distance(__first, __last));
       _M_range_initialize_n(__first, __last, __n);
       return;
     }
   else

   _M_range_initialize(__first, __last,
         std::__iterator_category(__first));
 }
# 799 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      ~vector() noexcept
      {
 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
                                      ;
      }
# 816 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector&
      operator=(const vector& __x);
# 831 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector&
      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
      {
 constexpr bool __move_storage =
   _Alloc_traits::_S_propagate_on_move_assign()
   || _Alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
 return *this;
      }
# 853 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      vector&
      operator=(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
 return *this;
      }
# 873 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 891 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 920 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      assign(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }
# 988 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      using _Base::get_allocator;







      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }







      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }




      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      {
 ptrdiff_t __dif = this->_M_impl._M_finish - this->_M_impl._M_start;
 if (__dif < 0)
    __builtin_unreachable ();
 return size_type(__dif);
      }


      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 1141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      resize(size_type __new_size)
      {
 if (__new_size > size())
   _M_default_append(__new_size - size());
 else if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
      }
# 1162 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      resize(size_type __new_size, const value_type& __x)
      {
 if (__new_size > size())
   _M_fill_insert(end(), __new_size - size(), __x);
 else if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
      }
# 1196 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }






      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      {
 ptrdiff_t __dif = this->_M_impl._M_end_of_storage
     - this->_M_impl._M_start;
 if (__dif < 0)
    __builtin_unreachable ();
 return size_type(__dif);
      }





      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return begin() == end(); }
# 1243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      reserve(size_type __n);
# 1259 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_impl._M_start + __n);
      }
# 1278 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      operator[](size_type __n) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_impl._M_start + __n);
      }

    protected:

      constexpr
      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
      }

    public:
# 1311 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1330 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      [[__nodiscard__]] constexpr
      reference
      front() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }





      [[__nodiscard__]] constexpr
      const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }





      [[__nodiscard__]] constexpr
      reference
      back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *(end() - 1);
      }





      [[__nodiscard__]] constexpr
      const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *(end() - 1);
      }
# 1393 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      _Tp*
      data() noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }

      [[__nodiscard__]] constexpr
      const _Tp*
      data() const noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }
# 1414 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      push_back(const value_type& __x)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
                                   ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         __x);
     ++this->_M_impl._M_finish;
                                   ;
   }
 else
   _M_realloc_append(__x);
      }


      constexpr
      void
      push_back(value_type&& __x)
      { emplace_back(std::move(__x)); }

      template<typename... _Args>

 constexpr
 reference



 emplace_back(_Args&&... __args);
# 1455 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      pop_back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 --this->_M_impl._M_finish;
 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
                                 ;
      }
# 1478 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename... _Args>
 constexpr
 iterator
 emplace(const_iterator __position, _Args&&... __args)
 { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
# 1495 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1526 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_insert_rval(__position, std::move(__x)); }
# 1544 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, initializer_list<value_type> __l)
      {
 auto __offset = __position - cbegin();
 _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
   std::random_access_iterator_tag());
 return begin() + __offset;
      }
# 1570 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, size_type __n, const value_type& __x)
      {
 difference_type __offset = __position - cbegin();
 _M_fill_insert(begin() + __offset, __n, __x);
 return begin() + __offset;
      }
# 1613 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
 insert(const_iterator __position, _InputIterator __first,
        _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_range_insert(begin() + __offset, __first, __last,
     std::__iterator_category(__first));
   return begin() + __offset;
 }
# 1789 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator

      erase(const_iterator __position)
      { return _M_erase(begin() + (__position - cbegin())); }
# 1817 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      iterator

      erase(const_iterator __first, const_iterator __last)
      {
 const auto __beg = begin();
 const auto __cbeg = cbegin();
 return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
      }
# 1842 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      constexpr
      void
      swap(vector& __x) noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) std::__glibcxx_assert_fail(); } while (false);


 this->_M_impl._M_swap_data(__x._M_impl);
 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
      __x._M_get_Tp_allocator());
      }







      constexpr
      void
      clear() noexcept
      { _M_erase_at_end(this->_M_impl._M_start); }

    private:

      struct _Guard_alloc
      {
 pointer _M_storage;
 size_type _M_len;
 _Base& _M_vect;

 constexpr
 _Guard_alloc(pointer __s, size_type __l, _Base& __vect)
 : _M_storage(__s), _M_len(__l), _M_vect(__vect)
 { }

 constexpr
 ~_Guard_alloc()
 {
   if (_M_storage)
     _M_vect._M_deallocate(_M_storage, _M_len);
 }

 constexpr
 pointer
 _M_release()
 {
   pointer __res = _M_storage;
   _M_storage = pointer();
   return __res;
 }

      private:
 _Guard_alloc(const _Guard_alloc&);
      };

    protected:




      template<typename _ForwardIterator>
 constexpr
 pointer
 _M_allocate_and_copy(size_type __n,
        _ForwardIterator __first, _ForwardIterator __last)
 {
   _Guard_alloc __guard(this->_M_allocate(__n), __n, *this);
   std::__uninitialized_copy_a
     (__first, __last, __guard._M_storage, _M_get_Tp_allocator());
   return __guard._M_release();
 }
# 1948 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename _InputIterator>
 constexpr
 void
 _M_range_initialize(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   try {
     for (; __first != __last; ++__first)

       emplace_back(*__first);



   } catch(...) {
     clear();
     throw;
   }
 }


      template<typename _ForwardIterator>
 constexpr
 void
 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
       std::forward_iterator_tag)
 {
   _M_range_initialize_n(__first, __last,
    std::distance(__first, __last));
 }

      template<typename _Iterator, typename _Sentinel>
 constexpr
 void
 _M_range_initialize_n(_Iterator __first, _Sentinel __last,
         size_type __n)
 {
   pointer __start =
     this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
   this->_M_impl._M_start = this->_M_impl._M_finish = __start;
   this->_M_impl._M_end_of_storage = __start + __n;
   this->_M_impl._M_finish
       = std::__uninitialized_copy_a(std::move(__first), __last,
         __start, _M_get_Tp_allocator());
 }



      constexpr
      void
      _M_fill_initialize(size_type __n, const value_type& __value)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
     _M_get_Tp_allocator());
      }



      constexpr
      void
      _M_default_initialize(size_type __n)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
        _M_get_Tp_allocator());
      }
# 2023 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      template<typename _Integer>
 constexpr
 void
 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
 { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
 constexpr
 void
 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }


      template<typename _InputIterator>
 constexpr
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
 constexpr
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      constexpr
      void
      _M_fill_assign(size_type __n, const value_type& __val);







      template<typename _Integer>
 constexpr
 void
 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
 { _M_fill_insert(__pos, __n, __val); }


      template<typename _InputIterator>
 constexpr
 void
 _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
 {
   _M_range_insert(__pos, __first, __last,
     std::__iterator_category(__first));
 }


      template<typename _InputIterator>
 constexpr
 void
 _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
 constexpr
 void
 _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      constexpr
      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);



      constexpr
      void
      _M_default_append(size_type __n);

      constexpr
      bool
      _M_shrink_to_fit();
# 2125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
      struct _Temporary_value
      {
 template<typename... _Args>
   constexpr explicit
   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
   {
     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
         std::forward<_Args>(__args)...);
   }

 constexpr
 ~_Temporary_value()
 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }

 constexpr value_type&
 _M_val() noexcept { return _M_storage._M_val; }

      private:
 constexpr _Tp*
 _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); }

 union _Storage
 {
   constexpr _Storage() : _M_byte() { }
   constexpr ~_Storage() { }
   _Storage& operator=(const _Storage&) = delete;
   unsigned char _M_byte;
   _Tp _M_val;
 };

 vector* _M_this;
 _Storage _M_storage;
      };



      template<typename _Arg>
 constexpr
 void
 _M_insert_aux(iterator __position, _Arg&& __arg);

      template<typename... _Args>
 constexpr
 void
 _M_realloc_insert(iterator __position, _Args&&... __args);

      template<typename... _Args>
 constexpr
 void
 _M_realloc_append(_Args&&... __args);


      constexpr
      iterator
      _M_insert_rval(const_iterator __position, value_type&& __v);


      template<typename... _Args>
 constexpr
 iterator
 _M_emplace_aux(const_iterator __position, _Args&&... __args);


      constexpr
      iterator
      _M_emplace_aux(const_iterator __position, value_type&& __v)
      { return _M_insert_rval(__position, std::move(__v)); }



      constexpr
      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + (std::max)(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }


      static constexpr size_type
      _S_check_init_len(size_type __n, const allocator_type& __a)
      {
 if (__n > _S_max_size(_Tp_alloc_type(__a)))
   __throw_length_error(
       ("cannot create std::vector larger than max_size()"));
 return __n;
      }

      static constexpr size_type
      _S_max_size(const _Tp_alloc_type& __a) noexcept
      {



 const size_t __diffmax
   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
 const size_t __allocmax = _Alloc_traits::max_size(__a);
 return (std::min)(__diffmax, __allocmax);
      }





      constexpr
      void
      _M_erase_at_end(pointer __pos) noexcept
      {
 if (size_type __n = this->_M_impl._M_finish - __pos)
   {
     std::_Destroy(__pos, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
     this->_M_impl._M_finish = __pos;
                                       ;
   }
      }

      constexpr
      iterator
      _M_erase(iterator __position);

      constexpr
      iterator
      _M_erase(iterator __first, iterator __last);


    private:



      constexpr
      void
      _M_move_assign(vector&& __x, true_type) noexcept
      {
 vector __tmp(get_allocator());
 this->_M_impl._M_swap_data(__x._M_impl);
 __tmp._M_impl._M_swap_data(__x._M_impl);
 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
      }



      constexpr
      void
      _M_move_assign(vector&& __x, false_type)
      {
 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
   _M_move_assign(std::move(__x), true_type());
 else
   {


     this->_M_assign_aux(std::make_move_iterator(__x.begin()),
           std::make_move_iterator(__x.end()),
    std::random_access_iterator_tag());
     __x.clear();
   }
      }


      template<typename _Up>
 constexpr
 _Up*
 _M_data_ptr(_Up* __ptr) const noexcept
 { return __ptr; }


      template<typename _Ptr>
 constexpr
 typename std::pointer_traits<_Ptr>::element_type*
 _M_data_ptr(_Ptr __ptr) const
 { return empty() ? nullptr : std::__to_address(__ptr); }






    };


  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>;
# 2335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return (__x.size() == __y.size()
       && std::equal(__x.begin(), __x.end(), __y.begin())); }
# 2354 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    [[nodiscard]]
    constexpr __detail::__synth3way_t<_Tp>
    operator<=>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    {
      return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
          __y.begin(), __y.end(),
          __detail::__synth3way);
    }
# 2407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    constexpr
    inline void
    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }




  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Alloc>
      struct _Never_valueless_alt<std::vector<_Tp, _Alloc>>
      : std::is_nothrow_move_assignable<std::vector<_Tp, _Alloc>>
      { };
  }



}
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 1 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  __attribute__((__nonnull__))
  constexpr
  void
  __fill_bvector_n(_Bit_type*, size_t, bool) noexcept;



  struct _Bit_reference
  {
  private:
    template<typename, typename> friend class vector;
    friend struct _Bit_iterator;
    friend struct _Bit_const_iterator;

    constexpr
    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }

    _Bit_type * _M_p;
    _Bit_type _M_mask;

    constexpr
    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

  public:

    _Bit_reference(const _Bit_reference&) = default;


    [[__nodiscard__]] constexpr
    operator bool() const noexcept
    { return !!(*_M_p & _M_mask); }

    constexpr
    _Bit_reference&
    operator=(bool __x) noexcept
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }
# 131 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
    constexpr
    _Bit_reference&
    operator=(const _Bit_reference& __x) noexcept
    { return *this = bool(__x); }

    [[__nodiscard__]] constexpr
    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    [[__nodiscard__]] constexpr
    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    constexpr
    void
    flip() noexcept
    { *_M_p ^= _M_mask; }


    constexpr
    friend void
    swap(_Bit_reference __x, _Bit_reference __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    constexpr
    friend void
    swap(_Bit_reference __x, bool& __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    constexpr
    friend void
    swap(bool& __x, _Bit_reference __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

  };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    constexpr inline __attribute__((__always_inline__))
    void
    _M_assume_normalized() const
    {




    }

    constexpr
    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    constexpr
    void
    _M_bump_up()
    {
      _M_assume_normalized();
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    constexpr
    void
    _M_bump_down()
    {
      _M_assume_normalized();
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    constexpr
    void
    _M_incr(ptrdiff_t __i)
    {
      _M_assume_normalized();
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   __n += int(_S_word_bit);
   --_M_p;
 }
      _M_offset = static_cast<unsigned int>(__n);
    }

    [[__nodiscard__]]
    friend constexpr bool
    operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset;
    }


    [[nodiscard]]
    friend constexpr strong_ordering
    operator<=>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    noexcept
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      if (const auto __cmp = __x._M_p <=> __y._M_p; __cmp != 0)
 return __cmp;
      return __x._M_offset <=> __y._M_offset;
    }
# 297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
    friend constexpr ptrdiff_t
    operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      return (int(_S_word_bit) * (__x._M_p - __y._M_p)
       + __x._M_offset - __y._M_offset);
    }
  };
#pragma GCC diagnostic pop

  struct _Bit_iterator : public _Bit_iterator_base
  {
    typedef _Bit_reference reference;

    typedef void pointer;



    typedef _Bit_iterator iterator;

    constexpr
    _Bit_iterator() : _Bit_iterator_base(0, 0) { }

    constexpr
    _Bit_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    constexpr
    iterator
    _M_const_cast() const
    { return *this; }

    [[__nodiscard__]] constexpr
    reference
    operator*() const
    {
      _M_assume_normalized();
      return reference(_M_p, 1UL << _M_offset);
    }

    constexpr
    iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    constexpr
    iterator
    operator++(int)
    {
      iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    constexpr
    iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    constexpr
    iterator
    operator--(int)
    {
      iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    constexpr
    iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    constexpr
    iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    [[__nodiscard__]] constexpr
    reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    [[__nodiscard__]]
    friend constexpr iterator
    operator+(const iterator& __x, difference_type __n)
    {
      iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr iterator
    operator+(difference_type __n, const iterator& __x)
    { return __x + __n; }

    [[__nodiscard__]]
    friend constexpr iterator
    operator-(const iterator& __x, difference_type __n)
    {
      iterator __tmp = __x;
      __tmp -= __n;
      return __tmp;
    }
  };

  struct _Bit_const_iterator : public _Bit_iterator_base
  {
    typedef bool reference;
    typedef bool const_reference;

    typedef void pointer;



    typedef _Bit_const_iterator const_iterator;

    constexpr
    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }

    constexpr
    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    constexpr
    _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }

    constexpr
    _Bit_iterator
    _M_const_cast() const
    { return _Bit_iterator(_M_p, _M_offset); }

    [[__nodiscard__]] constexpr
    const_reference
    operator*() const
    {
      _M_assume_normalized();
      return _Bit_reference(_M_p, 1UL << _M_offset);
    }

    constexpr
    const_iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    constexpr
    const_iterator
    operator++(int)
    {
      const_iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    constexpr
    const_iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    constexpr
    const_iterator
    operator--(int)
    {
      const_iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    constexpr
    const_iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    constexpr
    const_iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    [[__nodiscard__]] constexpr
    const_reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator+(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator-(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp -= __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator+(difference_type __n, const const_iterator& __x)
    { return __x + __n; }
  };

  template<typename _Alloc>
    struct _Bvector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
        rebind<_Bit_type>::other _Bit_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
 _Bit_alloc_traits;
      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;

      struct _Bvector_impl_data
      {

 _Bit_iterator _M_start;
# 553 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
 _Bit_iterator _M_finish;
 _Bit_pointer _M_end_of_storage;

 constexpr
 _Bvector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 _Bvector_impl_data(const _Bvector_impl_data&) = default;

 _Bvector_impl_data&
 operator=(const _Bvector_impl_data&) = default;

 constexpr
 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
 : _Bvector_impl_data(__x)
 { __x._M_reset(); }

 constexpr
 void
 _M_move_data(_Bvector_impl_data&& __x) noexcept
 {
   *this = __x;
   __x._M_reset();
 }


 constexpr
 void
 _M_reset() noexcept
 { *this = _Bvector_impl_data(); }

 constexpr
 void
 _M_swap_data(_Bvector_impl_data& __x) noexcept
 {


   std::swap(*this, __x);
 }
      };

      struct _Bvector_impl
 : public _Bit_alloc_type, public _Bvector_impl_data
      {
 constexpr
 _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)


 requires is_default_constructible_v<_Bit_alloc_type>

 : _Bit_alloc_type()
 { }

 constexpr
 _Bvector_impl(const _Bit_alloc_type& __a) noexcept
 : _Bit_alloc_type(__a)
 { }




 constexpr
 _Bvector_impl(_Bvector_impl&& __x) noexcept
 : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x))
 { }

 constexpr
 _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept
 : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x))
 { }


 constexpr
 _Bit_type*
 _M_end_addr() const noexcept
 {
   if (this->_M_end_of_storage)
     return std::__addressof(this->_M_end_of_storage[-1]) + 1;
   return 0;
 }
      };

    public:
      typedef _Alloc allocator_type;

      constexpr
      _Bit_alloc_type&
      _M_get_Bit_allocator() noexcept
      { return this->_M_impl; }

      constexpr
      const _Bit_alloc_type&
      _M_get_Bit_allocator() const noexcept
      { return this->_M_impl; }

      constexpr
      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Bit_allocator()); }


      _Bvector_base() = default;




      constexpr
      _Bvector_base(const allocator_type& __a)
      : _M_impl(_Bit_alloc_type(__a)) { }


      _Bvector_base(_Bvector_base&&) = default;

      constexpr
      _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept
      : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl))
      { }


      constexpr
      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      constexpr
      _Bit_pointer
      _M_allocate(size_t __n)
      {
 _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n));

 if (std::is_constant_evaluated())
   {
     __n = _S_nword(__n);
     for (size_t __i = 0; __i < __n; ++__i)
       std::construct_at(std::to_address(__p) + __i);
   }

 return __p;
      }

      constexpr
      void
      _M_deallocate()
      {
 if (_M_impl._M_start._M_p)
   {
     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
     _Bit_alloc_traits::deallocate(_M_impl,
       _M_impl._M_end_of_storage - __n,
       __n);
     _M_impl._M_reset();
   }
      }


      constexpr
      void
      _M_move_data(_Bvector_base&& __x) noexcept
      { _M_impl._M_move_data(std::move(__x._M_impl)); }


      constexpr
      static size_t
      _S_nword(size_t __n)
      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
    };
# 745 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;

      static_assert(is_same<typename _Alloc::value_type, bool>::value,
   "std::vector must have the same value_type as its allocator");



    public:
      typedef bool value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Bit_reference reference;
      typedef bool const_reference;
      typedef _Bit_reference* pointer;
      typedef const bool* const_pointer;
      typedef _Bit_iterator iterator;
      typedef _Bit_const_iterator const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef _Alloc allocator_type;

      constexpr
      allocator_type
      get_allocator() const
      { return _Base::get_allocator(); }

    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_S_nword;
      using _Base::_M_get_Bit_allocator;

    public:

      vector() = default;




      constexpr
      explicit
      vector(const allocator_type& __a) noexcept
      : _Base(__a) { }


      constexpr
      explicit
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : vector(__n, false, __a)
      { }

      constexpr
      vector(size_type __n, const bool& __value,
      const allocator_type& __a = allocator_type())





      : _Base(__a)
      {
 _M_initialize(__n);
 _M_initialize_value(__value);
      }

      constexpr
      vector(const vector& __x)
      : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
      {
 const_iterator __xbegin = __x.begin(), __xend = __x.end();
 _M_initialize(__x.size());
 _M_copy_aligned(__xbegin, __xend, begin());
      }


      vector(vector&&) = default;

    private:
      constexpr
      vector(vector&& __x, const allocator_type& __a, true_type) noexcept
      : _Base(std::move(__x), __a)
      { }

      constexpr
      vector(vector&& __x, const allocator_type& __a, false_type)
      : _Base(__a)
      {
 if (__x.get_allocator() == __a)
   this->_M_move_data(std::move(__x));
 else
   {
     _M_initialize(__x.size());
     _M_copy_aligned(__x.begin(), __x.end(), begin());
     __x.clear();
   }
      }

    public:
      constexpr
      vector(vector&& __x, const __type_identity_t<allocator_type>& __a)
      noexcept(_Bit_alloc_traits::_S_always_equal())
      : vector(std::move(__x), __a,
        typename _Bit_alloc_traits::is_always_equal{})
      { }

      constexpr
      vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
      : _Base(__a)
      {
 _M_initialize(__x.size());
 _M_copy_aligned(__x.begin(), __x.end(), begin());
      }

      constexpr
      vector(initializer_list<bool> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_initialize_range(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 {
   _M_initialize_range(__first, __last,
         std::__iterator_category(__first));
 }
# 925 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      ~vector() noexcept { }

      constexpr
      vector&
      operator=(const vector& __x)
      {
 if (&__x == this)
   return *this;

 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
   {
     if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
       {
  this->_M_deallocate();
  std::__alloc_on_copy(_M_get_Bit_allocator(),
         __x._M_get_Bit_allocator());
  _M_initialize(__x.size());
       }
     else
       std::__alloc_on_copy(_M_get_Bit_allocator(),
       __x._M_get_Bit_allocator());
   }

 if (__x.size() > capacity())
   {
     this->_M_deallocate();
     _M_initialize(__x.size());
   }
 this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
        begin());
 return *this;
      }


      constexpr
      vector&
      operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
      {
 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
     || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
   {
     this->_M_deallocate();
     this->_M_move_data(std::move(__x));
     std::__alloc_on_move(_M_get_Bit_allocator(),
     __x._M_get_Bit_allocator());
   }
 else
   {
     if (__x.size() > capacity())
       {
  this->_M_deallocate();
  _M_initialize(__x.size());
       }
     this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
            begin());
     __x.clear();
   }
 return *this;
      }

      constexpr
      vector&
      operator=(initializer_list<bool> __l)
      {
 this->assign(__l.begin(), __l.end());
 return *this;
      }






      constexpr
      void
      assign(size_type __n, const bool& __x)
      { _M_fill_assign(__n, __x); }


      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 1023 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      void
      assign(initializer_list<bool> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
# 1063 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      { return size_type(end() - begin()); }

      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      {
 const size_type __isize =
   __gnu_cxx::__numeric_traits<difference_type>::__max
   - int(_S_word_bit) + 1;
 const size_type __asize
   = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
 return (__asize <= __isize / int(_S_word_bit)
  ? __asize * int(_S_word_bit) : __isize);
      }

      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
    - begin()); }

      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return begin() == end(); }

      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __n)
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return _Bit_reference (this->_M_impl._M_start._M_p
          + __n / int(_S_word_bit),
          1UL << __n % int(_S_word_bit));
      }

      [[__nodiscard__]] constexpr
      const_reference
      operator[](size_type __n) const
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return _Bit_reference (this->_M_impl._M_start._M_p
          + __n / int(_S_word_bit),
          1UL << __n % int(_S_word_bit));
      }

    protected:
      constexpr
      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
      }

    public:
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }

      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }

      constexpr
      void
      reserve(size_type __n)
      {
 if (__n > max_size())
   __throw_length_error(("vector::reserve"));
 if (capacity() < __n)
   _M_reallocate(__n);
      }

      [[__nodiscard__]] constexpr
      reference
      front()
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }

      [[__nodiscard__]] constexpr
      const_reference
      front() const
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }

      [[__nodiscard__]] constexpr
      reference
      back()
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *(end() - 1);
      }

      [[__nodiscard__]] constexpr
      const_reference
      back() const
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *(end() - 1);
      }

      constexpr
      void
      push_back(bool __x)
      {
 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
   *this->_M_impl._M_finish++ = __x;
 else
   _M_insert_aux(end(), __x);
      }

      constexpr
      void
      swap(vector& __x) noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) std::__glibcxx_assert_fail(); } while (false);


 this->_M_impl._M_swap_data(__x._M_impl);
 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
          __x._M_get_Bit_allocator());
      }


      constexpr
      static void
      swap(reference __x, reference __y) noexcept
      {
 bool __tmp = __x;
 __x = __y;
 __y = __tmp;
      }

      constexpr
      iterator

      insert(const_iterator __position, const bool& __x)



      {
 const difference_type __n = __position - begin();
 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
     && __position == end())
   *this->_M_impl._M_finish++ = __x;
 else
   _M_insert_aux(__position._M_const_cast(), __x);
 return begin() + __n;
      }


      __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead")))
      iterator
      insert(const_iterator __position)
      { return this->insert(__position._M_const_cast(), false); }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
 insert(const_iterator __position,
        _InputIterator __first, _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_insert_range(__position._M_const_cast(),
     __first, __last,
     std::__iterator_category(__first));
   return begin() + __offset;
 }
# 1329 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, size_type __n, const bool& __x)
      {
 difference_type __offset = __position - cbegin();
 _M_fill_insert(__position._M_const_cast(), __n, __x);
 return begin() + __offset;
      }







      constexpr
      iterator
      insert(const_iterator __p, initializer_list<bool> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 1463 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      void
      pop_back()
      { --this->_M_impl._M_finish; }

      constexpr
      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }

      constexpr
      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }

      constexpr
      void
      resize(size_type __new_size, bool __x = bool())
      {
 if (__new_size < size())
   _M_erase_at_end(begin() + difference_type(__new_size));
 else
   insert(end(), __new_size - size(), __x);
      }


      constexpr
      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }


      constexpr
      void
      flip() noexcept
      {
 _Bit_type * const __end = this->_M_impl._M_end_addr();
 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
   *__p = ~*__p;
      }

      constexpr
      void
      clear() noexcept
      { _M_erase_at_end(begin()); }


      template<typename... _Args>

 constexpr
 reference



 emplace_back(_Args&&... __args)
 {
   push_back(bool(std::forward<_Args>(__args)...));

   return back();

 }

      template<typename... _Args>
 constexpr
 iterator
 emplace(const_iterator __pos, _Args&&... __args)
 { return insert(__pos, bool(std::forward<_Args>(__args)...)); }


    protected:

      constexpr
      iterator
      _M_copy_aligned(const_iterator __first, const_iterator __last,
        iterator __result)
      {
 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
 return std::copy(const_iterator(__last._M_p, 0), __last,
    iterator(__q, 0));
      }

      constexpr
      void
      _M_initialize(size_type __n)
      {
 if (__n)
   {
     _Bit_pointer __q = this->_M_allocate(__n);
     this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
     iterator __start = iterator(std::__addressof(*__q), 0);
     this->_M_impl._M_start = __start;
     this->_M_impl._M_finish = __start + difference_type(__n);
   }
      }

      constexpr
      void
      _M_initialize_value(bool __x) noexcept
      {
 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
   __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x);
      }

      constexpr
      void
      _M_reallocate(size_type __n);


      constexpr
      bool
      _M_shrink_to_fit();
# 1603 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      template<typename _InputIterator>
 constexpr
 void
 _M_initialize_range(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }

      template<typename _ForwardIterator>
 constexpr
 void
 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
       std::forward_iterator_tag)
 {
   const size_type __n = std::distance(__first, __last);
   _M_initialize(__n);
   std::copy(__first, __last, begin());
 }
# 1639 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      void
      _M_fill_assign(size_t __n, bool __x)
      {
 if (__n > size())
   {
     _M_initialize_value(__x);
     insert(end(), __n - size(), __x);
   }
 else
   {
     _M_erase_at_end(begin() + __n);
     _M_initialize_value(__x);
   }
      }

      template<typename _InputIterator>
 constexpr
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag)
 {
   iterator __cur = begin();
   for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
     *__cur = *__first;
   if (__first == __last)
     _M_erase_at_end(__cur);
   else
     insert(end(), __first, __last);
 }

      template<typename _ForwardIterator>
 constexpr
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag)
 {
   const size_type __len = std::distance(__first, __last);
   if (__len < size())
     _M_erase_at_end(std::copy(__first, __last, begin()));
   else
     {
       _ForwardIterator __mid = __first;
       std::advance(__mid, size());
       std::copy(__first, __mid, begin());
       insert(end(), __mid, __last);
     }
 }
# 1706 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_bvector.h" 3
      constexpr
      void
      _M_fill_insert(iterator __position, size_type __n, bool __x);

      template<typename _InputIterator>
 constexpr
 void
 _M_insert_range(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     {
       __pos = insert(__pos, *__first);
       ++__pos;
     }
 }

      template<typename _ForwardIterator>
 constexpr
 void
 _M_insert_range(iterator __position, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);

      constexpr
      void
      _M_insert_aux(iterator __position, bool __x);

      constexpr
      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + std::max(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }

      constexpr
      void
      _M_erase_at_end(iterator __pos)
      { this->_M_impl._M_finish = __pos; }

      constexpr
      iterator
      _M_erase(iterator __pos);

      constexpr
      iterator
      _M_erase(iterator __first, iterator __last);

    protected:






      void data() = delete;



    };




  constexpr
  inline void
  __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last,
   bool __x) noexcept
  {
    const _Bit_type __fmask = ~0ul << __first;
    const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
    const _Bit_type __mask = __fmask & __lmask;

    if (__x)
      *__v |= __mask;
    else
      *__v &= ~__mask;
  }


  __attribute__((__nonnull__))
  constexpr
  inline void
  __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept
  {

    if (std::is_constant_evaluated())
    {
      for (size_t __i = 0; __i < __n; ++__i)
 __p[__i] = __x ? ~0ul : 0ul;
      return;
    }

    __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type));
  }


  constexpr
  inline void
  __fill_a1(std::_Bit_iterator __first,
     std::_Bit_iterator __last, const bool& __x)
  {
    if (__first._M_p != __last._M_p)
      {
 _Bit_type* __first_p = __first._M_p;
 if (__first._M_offset != 0)
   __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);

 __fill_bvector_n(__first_p, __last._M_p - __first_p, __x);

 if (__last._M_offset != 0)
   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
      }
    else if (__first._M_offset != __last._M_offset)
      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
  }




  template<typename _Alloc>
    struct hash<std::vector<bool, _Alloc>>
    : public __hash_base<size_t, std::vector<bool, _Alloc>>
    {
      size_t
      operator()(const std::vector<bool, _Alloc>&) const noexcept;
    };



}
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/vector.tcc" 1 3
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/vector.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp;

   if constexpr (_S_use_relocate())
     {
       __tmp = this->_M_allocate(__n);
       _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
     __tmp, _M_get_Tp_allocator());
     }
   else

     {
       __tmp = _M_allocate_and_copy(__n,
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
                                ;
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>

      constexpr
      typename vector<_Tp, _Alloc>::reference



      vector<_Tp, _Alloc>::
      emplace_back(_Args&&... __args)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
                                   ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         std::forward<_Args>(__args)...);
     ++this->_M_impl._M_finish;
                                   ;
   }
 else
   _M_realloc_append(std::forward<_Args>(__args)...);

 return back();

      }


  template<typename _Tp, typename _Alloc>
    constexpr
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::

    insert(const_iterator __position, const value_type& __x)



    {
      const size_type __n = __position - begin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 {
   do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) std::__glibcxx_assert_fail(); } while (false);
   if (!(__position != const_iterator()))
     __builtin_unreachable();

   if (__position == end())
     {
                                     ;
       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
           __x);
       ++this->_M_impl._M_finish;
                                     ;
     }
   else
     {

       const auto __pos = begin() + (__position - cbegin());


       _Temporary_value __x_copy(this, __x);
       _M_insert_aux(__pos, std::move(__x_copy._M_val()));



     }
 }
      else

 _M_realloc_insert(begin() + (__position - cbegin()), __x);




      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
 std::move(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
                                      ;
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 {
   if (__last != end())
     std::move(__last, end(), __first);
   _M_erase_at_end(__first.base() + (end() - __last));
 }
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (std::__addressof(__x) != this)
 {
                                ;

   if (_Alloc_traits::_S_propagate_on_copy_assign())
     {
       if (!_Alloc_traits::_S_always_equal()
           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
         {

    this->clear();
    _M_deallocate(this->_M_impl._M_start,
    this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start);
    this->_M_impl._M_start = nullptr;
    this->_M_impl._M_finish = nullptr;
    this->_M_impl._M_end_of_storage = nullptr;
  }
       std::__alloc_on_copy(_M_get_Tp_allocator(),
       __x._M_get_Tp_allocator());
     }

   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
       end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
       __x._M_impl._M_finish,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    _M_fill_assign(size_t __n, const value_type& __val)
    {
      const size_type __sz = size();
      if (__n > capacity())
 {
   if (__n <= __sz)
     __builtin_unreachable();
   vector __tmp(__n, __val, _M_get_Tp_allocator());
   __tmp._M_impl._M_swap_data(this->_M_impl);
 }
      else if (__n > __sz)
 {
   std::fill(begin(), end(), __val);
   const size_type __add = __n - __sz;
                                     ;
   this->_M_impl._M_finish =
     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
       __add, __val, _M_get_Tp_allocator());
                                     ;
 }
      else
        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 pointer __cur(this->_M_impl._M_start);
 for (; __first != __last && __cur != this->_M_impl._M_finish;
      ++__cur, (void)++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   _M_range_insert(end(), __first, __last,
     std::__iterator_category(__first));
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __sz = size();
 const size_type __len = std::distance(__first, __last);

 if (__len > capacity())
   {
     if (__len <= __sz)
       __builtin_unreachable();

     _S_check_init_len(__len, _M_get_Tp_allocator());
     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
                                  ;
     _M_deallocate(this->_M_impl._M_start,
     this->_M_impl._M_end_of_storage
     - this->_M_impl._M_start);
     this->_M_impl._M_start = __tmp;
     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
   }
 else if (__sz >= __len)
   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, __sz);
     std::copy(__first, __mid, this->_M_impl._M_start);
     const size_type __attribute__((__unused__)) __n = __len - __sz;
                                     ;
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
                                     ;
   }
      }


  template<typename _Tp, typename _Alloc>
    constexpr
    auto
    vector<_Tp, _Alloc>::
    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
    {
      const auto __n = __position - cbegin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 if (__position == cend())
   {
                                   ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         std::move(__v));
     ++this->_M_impl._M_finish;
                                   ;
   }
 else
   _M_insert_aux(begin() + __n, std::move(__v));
      else
 _M_realloc_insert(begin() + __n, std::move(__v));

      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      auto
      vector<_Tp, _Alloc>::
      _M_emplace_aux(const_iterator __position, _Args&&... __args)
      -> iterator
      {
 const auto __n = __position - cbegin();
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   if (__position == cend())
     {
                                     ;
       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
           std::forward<_Args>(__args)...);
       ++this->_M_impl._M_finish;
                                     ;
     }
   else
     {



       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
     }
 else
   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);

 return iterator(this->_M_impl._M_start + __n);
      }

  template<typename _Tp, typename _Alloc>
    template<typename _Arg>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_insert_aux(iterator __position, _Arg&& __arg)






    {
                                    ;
      _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
          std::move(*(this->_M_impl._M_finish - 1)));
      ++this->_M_impl._M_finish;
                                    ;



      std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);





      *__position = std::forward<_Arg>(__arg);

    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_realloc_insert(iterator __position, _Args&&... __args)






    {
      const size_type __len = _M_check_len(1u, "vector::_M_realloc_insert");
      if (__len <= 0)
 __builtin_unreachable ();
      pointer __old_start = this->_M_impl._M_start;
      pointer __old_finish = this->_M_impl._M_finish;
      const size_type __elems_before = __position - begin();
      pointer __new_start(this->_M_allocate(__len));
      pointer __new_finish(__new_start);

      {
 _Guard_alloc __guard(__new_start, __len, *this);
# 481 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/vector.tcc" 3
 _Alloc_traits::construct(this->_M_impl,
     std::__to_address(__new_start + __elems_before),
     std::forward<_Args>(__args)...);







 if constexpr (_S_use_relocate())
   {

     __new_finish = _S_relocate(__old_start, __position.base(),
           __new_start, _M_get_Tp_allocator());
     ++__new_finish;
     __new_finish = _S_relocate(__position.base(), __old_finish,
           __new_finish, _M_get_Tp_allocator());
   }
 else

   {

     struct _Guard_elts
     {
       pointer _M_first, _M_last;
       _Tp_alloc_type& _M_alloc;

       constexpr
       _Guard_elts(pointer __elt, _Tp_alloc_type& __a)
       : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a)
       { }

       constexpr
       ~_Guard_elts()
       { std::_Destroy(_M_first, _M_last, _M_alloc); }

     private:
       _Guard_elts(const _Guard_elts&);
     };


     _Guard_elts __guard_elts(__new_start + __elems_before, _M_impl);

     __new_finish = std::__uninitialized_move_if_noexcept_a(
        __old_start, __position.base(),
        __new_start, _M_get_Tp_allocator());

     ++__new_finish;

     __guard_elts._M_first = __new_start;

     __new_finish = std::__uninitialized_move_if_noexcept_a(
         __position.base(), __old_finish,
         __new_finish, _M_get_Tp_allocator());


     __guard_elts._M_first = __old_start;
     __guard_elts._M_last = __old_finish;
   }
 __guard._M_storage = __old_start;
 __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
      }



      this->_M_impl._M_start = __new_start;
      this->_M_impl._M_finish = __new_finish;
      this->_M_impl._M_end_of_storage = __new_start + __len;
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_realloc_append(_Args&&... __args)






    {
      const size_type __len = _M_check_len(1u, "vector::_M_realloc_append");
      if (__len <= 0)
 __builtin_unreachable ();
      pointer __old_start = this->_M_impl._M_start;
      pointer __old_finish = this->_M_impl._M_finish;
      const size_type __elems = end() - begin();
      pointer __new_start(this->_M_allocate(__len));
      pointer __new_finish(__new_start);

      {
 _Guard_alloc __guard(__new_start, __len, *this);
# 586 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/vector.tcc" 3
 _Alloc_traits::construct(this->_M_impl,
     std::__to_address(__new_start + __elems),
     std::forward<_Args>(__args)...);







 if constexpr (_S_use_relocate())
   {

     __new_finish = _S_relocate(__old_start, __old_finish,
           __new_start, _M_get_Tp_allocator());
     ++__new_finish;
   }
 else

   {

     struct _Guard_elts
     {
       pointer _M_first, _M_last;
       _Tp_alloc_type& _M_alloc;

       constexpr
       _Guard_elts(pointer __elt, _Tp_alloc_type& __a)
       : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a)
       { }

       constexpr
       ~_Guard_elts()
       { std::_Destroy(_M_first, _M_last, _M_alloc); }

     private:
       _Guard_elts(const _Guard_elts&);
     };


     _Guard_elts __guard_elts(__new_start + __elems, _M_impl);

     __new_finish = std::__uninitialized_move_if_noexcept_a(
        __old_start, __old_finish,
        __new_start, _M_get_Tp_allocator());

     ++__new_finish;


     __guard_elts._M_first = __old_start;
     __guard_elts._M_last = __old_finish;
   }
 __guard._M_storage = __old_start;
 __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
      }



      this->_M_impl._M_start = __new_start;
      this->_M_impl._M_finish = __new_finish;
      this->_M_impl._M_end_of_storage = __new_start + __len;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
 {
   if (size_type(this->_M_impl._M_end_of_storage
   - this->_M_impl._M_finish) >= __n)
     {



       _Temporary_value __tmp(this, __x);
       value_type& __x_copy = __tmp._M_val();

       const size_type __elems_after = end() - __position;
       pointer __old_finish(this->_M_impl._M_finish);
       if (__elems_after > __n)
  {
                                    ;
    std::__uninitialized_move_a(__old_finish - __n,
           __old_finish,
           __old_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n;
                                    ;
    std::move_backward(__position.base(), __old_finish - __n, __old_finish);

    std::fill(__position.base(), __position.base() + __n,
       __x_copy);
  }
       else
  {
                                    ;
    this->_M_impl._M_finish =
      std::__uninitialized_fill_n_a(__old_finish,
        __n - __elems_after,
        __x_copy,
        _M_get_Tp_allocator());
                                                    ;
    std::__uninitialized_move_a(__position.base(), __old_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __elems_after;
                                              ;
    std::fill(__position.base(), __old_finish, __x_copy);
  }
     }
   else
     {


       pointer __old_start = this->_M_impl._M_start;
       pointer __old_finish = this->_M_impl._M_finish;
       const pointer __pos = __position.base();

       const size_type __len =
  _M_check_len(__n, "vector::_M_fill_insert");
       const size_type __elems_before = __pos - __old_start;
       pointer __new_start(this->_M_allocate(__len));
       pointer __new_finish(__new_start);
       try
  {

    std::__uninitialized_fill_n_a(__new_start + __elems_before,
      __n, __x,
      _M_get_Tp_allocator());
    __new_finish = pointer();

    __new_finish
      = std::__uninitialized_move_if_noexcept_a
      (__old_start, __pos, __new_start, _M_get_Tp_allocator());

    __new_finish += __n;

    __new_finish
      = std::__uninitialized_move_if_noexcept_a
      (__pos, __old_finish, __new_finish, _M_get_Tp_allocator());
  }
       catch(...)
  {
    if (!__new_finish)
      std::_Destroy(__new_start + __elems_before,
      __new_start + __elems_before + __n,
      _M_get_Tp_allocator());
    else
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
    _M_deallocate(__new_start, __len);
    throw;
  }
       std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
                                    ;
       _M_deallocate(__old_start,
       this->_M_impl._M_end_of_storage - __old_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_finish;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }


  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    _M_default_append(size_type __n)
    {
      if (__n != 0)
 {
   const size_type __size = size();
   size_type __navail = size_type(this->_M_impl._M_end_of_storage
      - this->_M_impl._M_finish);

   if (__size > max_size() || __navail > max_size() - __size)
     __builtin_unreachable();

   if (__navail >= __n)
     {
       if (!this->_M_impl._M_finish)
  __builtin_unreachable();

                                       ;
       this->_M_impl._M_finish =
  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
       __n, _M_get_Tp_allocator());
                                       ;
     }
   else
     {


       pointer __old_start = this->_M_impl._M_start;
       pointer __old_finish = this->_M_impl._M_finish;

       const size_type __len =
  _M_check_len(__n, "vector::_M_default_append");
       pointer __new_start(this->_M_allocate(__len));

       {
  _Guard_alloc __guard(__new_start, __len, *this);

  std::__uninitialized_default_n_a(__new_start + __size, __n,
       _M_get_Tp_allocator());

  if constexpr (_S_use_relocate())
    {
      _S_relocate(__old_start, __old_finish,
    __new_start, _M_get_Tp_allocator());
    }
  else
    {

      struct _Guard_elts
      {
        pointer _M_first, _M_last;
        _Tp_alloc_type& _M_alloc;

        constexpr
        _Guard_elts(pointer __first, size_type __n,
      _Tp_alloc_type& __a)
        : _M_first(__first), _M_last(__first + __n), _M_alloc(__a)
        { }

        constexpr
        ~_Guard_elts()
        { std::_Destroy(_M_first, _M_last, _M_alloc); }

      private:
        _Guard_elts(const _Guard_elts&);
      };
      _Guard_elts __guard_elts(__new_start + __size, __n, _M_impl);

      std::__uninitialized_move_if_noexcept_a(
        __old_start, __old_finish, __new_start,
        _M_get_Tp_allocator());

      __guard_elts._M_first = __old_start;
      __guard_elts._M_last = __old_finish;
    }
                               ;
  __guard._M_storage = __old_start;
  __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
       }



       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_start + __size + __n;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    bool
    vector<_Tp, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() == size())
 return false;
                                   ;
      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
    }


  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 if (__pos == end())
   {
     for (; __first != __last; ++__first)
       insert(end(), *__first);
   }
 else if (__first != __last)
   {
     vector __tmp(__first, __last, _M_get_Tp_allocator());
     insert(__pos,
     std::make_move_iterator(__tmp.begin()),
     std::make_move_iterator(__tmp.end()));
   }
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     const size_type __n = std::distance(__first, __last);
     if (size_type(this->_M_impl._M_end_of_storage
     - this->_M_impl._M_finish) >= __n)
       {
  const size_type __elems_after = end() - __position;
  pointer __old_finish(this->_M_impl._M_finish);
  if (__elems_after > __n)
    {
                                      ;
      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
      this->_M_impl._M_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n;
                                      ;
      std::move_backward(__position.base(), __old_finish - __n, __old_finish);

      std::copy(__first, __last, __position);
    }
  else
    {
      _ForwardIterator __mid = __first;
      std::advance(__mid, __elems_after);
                                      ;
      std::__uninitialized_copy_a(__mid, __last,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n - __elems_after;
                                                      ;
      std::__uninitialized_move_a(__position.base(),
      __old_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __elems_after;
                                                ;
      std::copy(__first, __mid, __position);
    }
       }
     else
       {



  pointer __old_start = this->_M_impl._M_start;
  pointer __old_finish = this->_M_impl._M_finish;

  const size_type __len =
    _M_check_len(__n, "vector::_M_range_insert");





  pointer __new_start(this->_M_allocate(__len));
  pointer __new_finish(__new_start);
  try
    {
      __new_finish
        = std::__uninitialized_move_if_noexcept_a
        (__old_start, __position.base(),
         __new_start, _M_get_Tp_allocator());
      __new_finish
        = std::__uninitialized_copy_a(__first, __last,
          __new_finish,
          _M_get_Tp_allocator());
      __new_finish
        = std::__uninitialized_move_if_noexcept_a
        (__position.base(), __old_finish,
         __new_finish, _M_get_Tp_allocator());
    }
  catch(...)
    {
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
      _M_deallocate(__new_start, __len);
      throw;
    }
  std::_Destroy(__old_start, __old_finish,
         _M_get_Tp_allocator());
                               ;
  _M_deallocate(__old_start,
         this->_M_impl._M_end_of_storage - __old_start);
  this->_M_impl._M_start = __new_start;
  this->_M_impl._M_finish = __new_finish;
  this->_M_impl._M_end_of_storage = __new_start + __len;
       }
   }
      }
# 1106 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/vector.tcc" 3
  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_reallocate(size_type __n)
    {
      const iterator __begin = begin(), __end = end();
      if (size_type(__end - __begin) > __n)
 __builtin_unreachable();
      _Bit_pointer __q = this->_M_allocate(__n);
      iterator __start(std::__addressof(*__q), 0);
      iterator __finish(_M_copy_aligned(__begin, __end, __start));
      this->_M_deallocate();
      this->_M_impl._M_start = __start;
      this->_M_impl._M_finish = __finish;
      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
    }

  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, bool __x)
    {
      if (__n == 0)
 return;
      if (capacity() - size() >= __n)
 {
   std::copy_backward(__position, end(),
        this->_M_impl._M_finish + difference_type(__n));
   std::fill(__position, __position + difference_type(__n), __x);
   this->_M_impl._M_finish += difference_type(__n);
 }
      else
 {
   const size_type __len =
     _M_check_len(__n, "vector<bool>::_M_fill_insert");
   iterator __begin = begin(), __end = end();
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(__begin, __position, __start);
   std::fill(__i, __i + difference_type(__n), __x);
   iterator __finish = std::copy(__position, __end,
     __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      void
      vector<bool, _Alloc>::
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     size_type __n = std::distance(__first, __last);
     if (capacity() - size() >= __n)
       {
  std::copy_backward(__position, end(),
       this->_M_impl._M_finish
       + difference_type(__n));
  std::copy(__first, __last, __position);
  this->_M_impl._M_finish += difference_type(__n);
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector<bool>::_M_insert_range");
  const iterator __begin = begin(), __end = end();
  _Bit_pointer __q = this->_M_allocate(__len);
  iterator __start(std::__addressof(*__q), 0);
  iterator __i = _M_copy_aligned(__begin, __position, __start);
  __i = std::copy(__first, __last, __i);
  iterator __finish = std::copy(__position, __end, __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
  this->_M_impl._M_start = __start;
  this->_M_impl._M_finish = __finish;
       }
   }
      }

  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_insert_aux(iterator __position, bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
 {
   std::copy_backward(__position, this->_M_impl._M_finish,
        this->_M_impl._M_finish + 1);
   *__position = __x;
   ++this->_M_impl._M_finish;
 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(begin(), __position, __start);
   *__i++ = __x;
   iterator __finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    constexpr
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      return __position;
    }

  template<typename _Alloc>
    constexpr
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 _M_erase_at_end(std::copy(__last, end(), __first));
      return __first;
    }


  template<typename _Alloc>
    constexpr
    bool
    vector<bool, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() - size() < int(_S_word_bit))
 return false;
      try
 {
   if (size_type __n = size())
     _M_reallocate(__n);
   else
     {
       this->_M_deallocate();
       this->_M_impl._M_reset();
     }
   return true;
 }
      catch(...)
 { return false; }
    }




}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Alloc>
    size_t
    hash<std::vector<bool, _Alloc>>::
    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
    {
      size_t __hash = 0;
      const size_t __words = __b.size() / _S_word_bit;
      if (__words)
 {
   const size_t __clength = __words * sizeof(_Bit_type);
   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
 }

      const size_t __extrabits = __b.size() % _S_word_bit;
      if (__extrabits)
 {
   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);

   const size_t __clength
     = (__extrabits + 8 - 1) / 8;
   if (__words)
     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
   else
     __hash = std::_Hash_impl::hash(&__hiword, __clength);
 }

      return __hash;
    }


}
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 2 3
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr {
    template<typename _Tp>
      using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
  }
# 107 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/vector" 3
}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, typename _Alloc, typename _Predicate>
    constexpr
    inline typename vector<_Tp, _Alloc>::size_type
    erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      std::vector<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

  template<typename _Tp, typename _Alloc,
    typename _Up >
    constexpr
    inline typename vector<_Tp, _Alloc>::size_type
    erase(vector<_Tp, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      std::vector<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__iter_equals_val(__value));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

}
# 18 "include/klm/bklm/geometry/Module.h" 2

namespace Belle2 {

  namespace bklm {
# 72 "include/klm/bklm/geometry/Module.h"
    class Module {

    public:


      Module(void);


      Module(double phiStripWidth,
             int phiStripMin,
             int phiStripMax,
             double zStripWidth,
             int zStripNumber,
             const CLHEP::Hep3Vector& globalOrigin,
             const CLHEP::Hep3Vector& localReconstructionShift,
             const CLHEP::HepRotation& rotation);


      Module(double stripWidth,
             int phiStripNumber,
             int phiSensorSide,
             int zStripNumber,
             const CLHEP::Hep3Vector& globalOrigin,
             const CLHEP::Hep3Vector& localReconstructionShift,
             const CLHEP::HepRotation& rotation,
             bool isFlipped);


      Module(const Module& m);


      Module& operator=(const Module& m);


      ~Module();


      bool isFlipped() const
      {
        return m_IsFlipped;
      }


      bool hasRPCs() const
      {
        return m_HasRPCs;
      }


      int getPhiStripMin() const
      {
        return m_PhiStripMin;
      }


      int getPhiStripMax() const
      {
        return m_PhiStripMax;
      }


      double getPhiStripWidth() const
      {
        return m_PhiStripWidth;
      }


      int getZStripMin() const
      {
        return m_ZStripMin;
      }


      int getZStripMax() const
      {
        return m_ZStripMax;
      }


      double getZStripWidth() const
      {
        return m_ZStripWidth;
      }


      void addPhiScint(int scint, double length, double offset, double position);


      void addZScint(int scint, double length, double offset, double position);


      double getPhiScintHalfLength(int scint) const
      {
        return 0.5 * m_PhiScintLengths[scint];
      }


      double getPhiScintOffset(int scint) const
      {
        return m_PhiScintOffsets[scint];
      }


      double getPhiScintPosition(int scint) const
      {
        return m_PhiScintPositions[scint];
      }


      double getZScintHalfLength(int scint) const
      {
        return 0.5 * m_ZScintLengths[scint];
      }


      double getZScintOffset(int scint) const
      {
        return m_ZScintOffsets[scint];
      }


      double getZScintPosition(int scint) const
      {
        return m_ZScintPositions[scint];
      }


      double getStripLength(int plane, int strip) const;


      const CLHEP::Hep3Vector getLocalPosition(double phiStripAve, double zStripAve) const;



      const CLHEP::Hep3Vector getPropagationDistance(const CLHEP::Hep3Vector&) const;



      double getPropagationDistance(const CLHEP::Hep3Vector& local,
                                    int strip, bool phiReadout) const;



      const CLHEP::Hep3Vector getPropagationDistance(
        const CLHEP::Hep3Vector&, int stripZ, int stripPhi) const;



      const CLHEP::Hep3Vector getPropagationTimes(const CLHEP::Hep3Vector&) const;



      double getPropagationTime(const CLHEP::Hep3Vector& local,
                                int strip, bool phiReadout) const;



      const CLHEP::Hep3Vector getPropagationTimes(
        const CLHEP::Hep3Vector&, int stripZ, int stripPhi) const;


      double getPhiStrip(const CLHEP::Hep3Vector& p) const
      {
        return p.y() / m_PhiStripWidth + m_PhiPositionBase;
      }


      double getZStrip(const CLHEP::Hep3Vector& p) const
      {
        return p.z() / m_ZStripWidth + m_ZPositionBase;
      }



      int getPhiStripNumber(const CLHEP::Hep3Vector& p) const;



      int getZStripNumber(const CLHEP::Hep3Vector& p) const;




      const CLHEP::Hep3Vector localToGlobal(const CLHEP::Hep3Vector& v, bool reco = false) const;


      const CLHEP::Hep3Vector RotateToLocal(const CLHEP::Hep3Vector& v) const
      {
        return m_RotationInverse * v;
      }


      const CLHEP::Hep3Vector RotateToGlobal(const CLHEP::Hep3Vector& v) const
      {
        return m_Rotation * v;
      }




      const CLHEP::Hep3Vector globalToLocal(const CLHEP::Hep3Vector& v, bool reco = false) const;


      const CLHEP::Hep3Vector getLocalReconstructionShift() const
      {
        return m_LocalReconstructionShift;
      }


      const CLHEP::Hep3Vector getGlobalOrigin() const
      {
        return m_GlobalOrigin;
      }


      void setAlignment(const HepGeom::Transform3D& moduleAlignment);


      void setDisplacedGeo(const HepGeom::Transform3D& moduleDisplacedGeo);


      const HepGeom::Transform3D getAlignment() const
      {
        return m_Alignment;
      }


      const HepGeom::Transform3D getDisplacedGeo() const
      {
        return m_DisplacedGeo;
      }


      const CLHEP::HepRotation getRotationFromTransform3D(const HepGeom::Transform3D& trans) const;


      const CLHEP::Hep3Vector getTranslationFromTransform3D(const HepGeom::Transform3D& trans) const;

    private:


      bool m_HasRPCs;


      bool m_IsFlipped;


      double m_PhiStripWidth;


      int m_PhiStripMin;


      int m_PhiStripMax;


      double m_PhiPositionBase;


      double m_ZStripWidth;


      int m_ZStripMin;


      int m_ZStripMax;


      double m_ZPositionBase;


      int m_PhiSensorSide;


      double m_SignalSpeed;


      CLHEP::Hep3Vector m_GlobalOrigin;


      CLHEP::Hep3Vector m_LocalReconstructionShift;


      CLHEP::HepRotation m_Rotation;


      CLHEP::HepRotation m_RotationInverse;


      HepGeom::Transform3D m_Alignment;


      CLHEP::HepRotation m_AlignmentRotation;


      CLHEP::Hep3Vector m_AlignmentTranslation;


      HepGeom::Transform3D m_AlignmentInverse;


      CLHEP::HepRotation m_AlignmentRotationInverse;


      HepGeom::Transform3D m_DisplacedGeo;


      CLHEP::HepRotation m_DisplacedGeoRotation;


      CLHEP::Hep3Vector m_DisplacedGeoTranslation;


      HepGeom::Transform3D m_DisplacedGeoInverse;


      CLHEP::HepRotation m_DisplacedGeoRotationInverse;


      std::vector<double> m_PhiScintLengths;


      std::vector<double> m_PhiScintPositions;


      std::vector<double> m_PhiScintOffsets;


      std::vector<double> m_ZScintLengths;


      std::vector<double> m_ZScintPositions;


      std::vector<double> m_ZScintOffsets;

    };

  }

}
# 13 "include/klm/bklm/geometry/GeometryPar.h" 2
# 1 "include/klm/dbobjects/bklm/BKLMGeometryPar.h" 1
# 12 "include/klm/dbobjects/bklm/BKLMGeometryPar.h"
# 1 "include/klm/dataobjects/bklm/BKLMElementNumbers.h" 1
# 12 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
# 1 "include/klm/dataobjects/KLMElementNumberDefinitions.h" 1
# 12 "include/klm/dataobjects/KLMElementNumberDefinitions.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdint" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdint" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdint.h" 1 3
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdint.h" 3
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4


# 1 "/usr/include/bits/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;
# 87 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;


typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdint.h" 2 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 144 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdint" 3
}
# 13 "include/klm/dataobjects/KLMElementNumberDefinitions.h" 2

namespace Belle2 {


  typedef uint16_t KLMSubdetectorNumber;


  typedef uint16_t KLMSectionNumber;


  typedef uint16_t KLMSectorNumber;


  typedef uint16_t KLMModuleNumber;


  typedef uint16_t KLMPlaneNumber;


  typedef uint16_t KLMChannelNumber;


  typedef uint16_t EKLMSegmentNumber;

}
# 13 "include/klm/dataobjects/bklm/BKLMElementNumbers.h" 2





namespace Belle2 {




  class BKLMElementNumbers {

  public:




    enum Section {


      c_BackwardSection = 0,


      c_ForwardSection = 1,

    };




    enum Sector {






      c_ChimneySector = 3,

    };




    enum Layer {


      c_FirstRPCLayer = 3,

    };




    enum Plane {


      c_ZPlane = 0,


      c_PhiPlane = 1,

    };




    BKLMElementNumbers();




    ~BKLMElementNumbers();
# 95 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static KLMChannelNumber channelNumber(int section, int sector, int layer,
                                          int plane, int strip);
# 107 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static void channelNumberToElementNumbers(
      KLMChannelNumber channel, int* section, int* sector, int* layer, int* plane,
      int* strip);
# 118 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static KLMPlaneNumber planeNumber(int section, int sector, int layer,
                                      int plane);
# 129 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static void planeNumberToElementNumbers(
      KLMPlaneNumber planeGlobal, int* section, int* sector, int* layer,
      int* plane);
# 140 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static KLMModuleNumber moduleNumber(int section, int sector, int layer,
                                        bool fatalError = true);
# 150 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static void moduleNumberToElementNumbers(
      KLMModuleNumber module, int* section, int* sector, int* layer);






    static KLMSectorNumber sectorNumber(int section, int sector);







    static int layerGlobalNumber(int section, int sector, int layer);
# 175 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static int getNStrips(int section, int sector, int layer, int plane);






    static bool checkSection(int section, bool fatalError = true);






    static bool checkSector(int sector, bool fatalError = true);






    static bool checkLayer(int layer, bool fatalError = true);






    static bool checkPlane(int plane, bool fatalError = true);
# 214 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static bool checkChannelNumber(
      int section, int sector, int layer, int plane, int strip, bool fatalError = true);






    static std::string getHSLBName(int copper, int slot);




    static constexpr int getMaximalSectionNumber()
    {
      return m_MaximalSectionNumber;
    }




    static constexpr int getMaximalSectorNumber()
    {
      return m_MaximalSectorNumber;
    }




    static constexpr int getMaximalLayerNumber()
    {
      return m_MaximalLayerNumber;
    }




    static constexpr int getMaximalPlaneNumber()
    {
      return m_MaximalPlaneNumber;
    }




    static constexpr int getMaximalSectorGlobalNumber()
    {
      return (m_MaximalSectionNumber + 1) * m_MaximalSectorNumber;
    }




    static constexpr int getMaximalLayerGlobalNumber()
    {
      return (m_MaximalSectionNumber + 1) * m_MaximalSectorNumber * m_MaximalLayerNumber;
    }




    static constexpr int getTotalChannelNumber()
    {
      return m_TotalChannelNumber;
    }
# 287 "include/klm/dataobjects/bklm/BKLMElementNumbers.h"
    static void layerGlobalNumberToElementNumbers(int layerGlobal, int* section, int* sector, int* layer);




    static int getSectionByModule(int module)
    {
      return (module & BKLM_SECTION_MASK) >> BKLM_SECTION_BIT;
    }




    static int getSectorByModule(int module)
    {
      return ((module & BKLM_SECTOR_MASK) >> BKLM_SECTOR_BIT) + 1;
    }




    static int getLayerByModule(int module)
    {
      return ((module & BKLM_LAYER_MASK) >> BKLM_LAYER_BIT) + 1;
    }




    static int getPlaneByModule(int module)
    {
      return (module & BKLM_PLANE_MASK) >> BKLM_PLANE_BIT;
    }




    static int getStripByModule(int module)
    {
      return ((module & BKLM_STRIP_MASK) >> BKLM_STRIP_BIT) + 1;
    }






    static void setSectionInModule(int& module, int section)
    {
      module = (module & (~BKLM_SECTION_MASK)) | (section << BKLM_SECTION_BIT);
    }






    static void setSectorInModule(int& module, int sector)
    {
      module = (module & (~BKLM_SECTOR_MASK)) | ((sector - 1) << BKLM_SECTOR_BIT);
    }






    static void setLayerInModule(int& module, int layer)
    {
      module = (module & (~BKLM_LAYER_MASK)) | ((layer - 1) << BKLM_LAYER_BIT);
    }






    static void setPlaneInModule(int& module, int plane)
    {
      module = (module & (~BKLM_PLANE_MASK)) | (plane << BKLM_PLANE_BIT);
    }






    static void setStripInModule(int& module, int strip)
    {
      module = (module & (~BKLM_STRIP_MASK)) | ((strip - 1) << BKLM_STRIP_BIT);
    }





    static uint16_t getModuleByModule(int module)
    {
      return module & BKLM_MODULEID_MASK;
    }




    static uint16_t getChannelByModule(int module)
    {
      return module & BKLM_MODULESTRIPID_MASK;
    }




    static bool hitsFromSameModule(int module1, int module2)
    {
      return getModuleByModule(module1) == getModuleByModule(module2);
    }




    static bool hitsFromSamePlane(int module1, int module2)
    {
      const int mask = BKLM_MODULEID_MASK | BKLM_PLANE_MASK;
      return (module1 & mask) == (module2 & mask);
    }




    static bool hitsFromSameChannel(int module1, int module2)
    {
      return getChannelByModule(module1) == getChannelByModule(module2);
    }

  protected:


    static constexpr int m_MaximalSectionNumber = 1;


    static constexpr int m_MaximalSectorNumber = 8;


    static constexpr int m_MaximalLayerNumber = 15;


    static constexpr int m_MaximalPlaneNumber = 1;


    static constexpr int m_TotalChannelNumber = 21978;


    static constexpr int BKLM_STRIP_BIT = 0;





    static constexpr int BKLM_PLANE_BIT = 6;


    static constexpr int BKLM_LAYER_BIT = 7;





    static constexpr int BKLM_SECTOR_BIT = 11;


    static constexpr int BKLM_SECTION_BIT = 14;


    static constexpr int BKLM_STRIP_MASK = (63 << BKLM_STRIP_BIT);


    static constexpr int BKLM_PLANE_MASK = (1 << BKLM_PLANE_BIT);


    static constexpr int BKLM_LAYER_MASK = (15 << BKLM_LAYER_BIT);





    static constexpr int BKLM_SECTOR_MASK = (7 << BKLM_SECTOR_BIT);


    static constexpr int BKLM_SECTION_MASK = (1 << BKLM_SECTION_BIT);


    static constexpr int BKLM_MODULEID_MASK =
      BKLM_SECTION_MASK | BKLM_SECTOR_MASK | BKLM_LAYER_MASK;


    static constexpr int BKLM_MODULESTRIPID_MASK =
      BKLM_SECTION_MASK | BKLM_SECTOR_MASK | BKLM_LAYER_MASK | BKLM_PLANE_MASK |
      BKLM_STRIP_MASK;

  };

}
# 13 "include/klm/dbobjects/bklm/BKLMGeometryPar.h" 2


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/RtypesCore.h" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/RtypesCore.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RConfig.hxx" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RConfig.hxx" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/../RVersion.h" 1 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/../ROOT/RVersion.hxx" 1 3
# 5 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/../RVersion.h" 2 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RConfig.hxx" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/RConfigure.h" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RConfig.hxx" 2 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/RtypesCore.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/DllImport.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/RtypesCore.h" 2 3







class TRootIOCtor;



typedef char Char_t;
typedef unsigned char UChar_t;
typedef short Short_t;
typedef unsigned short UShort_t;




typedef int Int_t;
typedef unsigned int UInt_t;


typedef int Seek_t;
typedef long Long_t;
typedef unsigned long ULong_t;





typedef float Float_t;
typedef float Float16_t;
typedef double Double_t;
typedef double Double32_t;
typedef long double LongDouble_t;
typedef char Text_t;
typedef bool Bool_t;
typedef unsigned char Byte_t;
typedef short Version_t;
typedef const char Option_t;
typedef int Ssiz_t;
typedef float Real_t;
typedef long long Long64_t;
typedef unsigned long long ULong64_t;




typedef long Longptr_t;
typedef unsigned long ULongptr_t;

typedef double Axis_t;
typedef double Stat_t;

typedef short Font_t;
typedef short Style_t;
typedef short Marker_t;
typedef short Width_t;
typedef short Color_t;
typedef short SCoord_t;
typedef double Coord_t;
typedef float Angle_t;
typedef float Size_t;



constexpr Bool_t kTRUE = true;
constexpr Bool_t kFALSE = false;

constexpr Int_t kMaxUChar = 256;
constexpr Int_t kMaxChar = kMaxUChar >> 1;
constexpr Int_t kMinChar = -kMaxChar - 1;

constexpr Int_t kMaxUShort = 65534;
constexpr Int_t kMaxShort = kMaxUShort >> 1;
constexpr Int_t kMinShort = -kMaxShort - 1;

constexpr UInt_t kMaxUInt = UInt_t(~0);
constexpr Int_t kMaxInt = Int_t(kMaxUInt >> 1);
constexpr Int_t kMinInt = -kMaxInt - 1;

constexpr ULong_t kMaxULong = ULong_t(~0);
constexpr Long_t kMaxLong = Long_t(kMaxULong >> 1);
constexpr Long_t kMinLong = -kMaxLong - 1;

constexpr ULong64_t kMaxULong64 = ULong64_t(~0LL);
constexpr Long64_t kMaxLong64 = Long64_t(kMaxULong64 >> 1);
constexpr Long64_t kMinLong64 = -kMaxLong64 - 1;

constexpr ULong_t kBitsPerByte = 8;
constexpr Ssiz_t kNPOS = ~(Ssiz_t)0;



 extern Int_t gDebug;
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/strtok.h" 1 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstring" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstring" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstring" 2 3
# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
       size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, const void *__src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
        int __c, size_t __n)
    noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int memcmp (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 80 "/usr/include/string.h" 3 4
extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
memchr (void *__s, int __c, size_t __n) noexcept (true)
{
  return __builtin_memchr (__s, __c, __n);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
memchr (const void *__s, int __c, size_t __n) noexcept (true)
{
  return __builtin_memchr (__s, __c, __n);
}

}
# 115 "/usr/include/string.h" 3 4
extern "C++" void *rawmemchr (void *__s, int __c)
     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
                                           ;
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
                                           ;
# 141 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, const char *__restrict __src,
        size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (const char *__s1, const char *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
    noexcept (true) __attribute__ ((__nonnull__ (2))) ;






extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));


extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
    locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4)))
                                           ;





extern char *strdup (const char *__s)
     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (const char *__string, size_t __n)
     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 224 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strchr (char *__s, int __c) noexcept (true)
{
  return __builtin_strchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strchr (const char *__s, int __c) noexcept (true)
{
  return __builtin_strchr (__s, __c);
}

}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strrchr (char *__s, int __c) noexcept (true)
{
  return __builtin_strrchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strrchr (const char *__s, int __c) noexcept (true)
{
  return __builtin_strrchr (__s, __c);
}

}
# 281 "/usr/include/string.h" 3 4
extern "C++" char *strchrnul (char *__s, int __c)
     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 293 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (const char *__s, const char *__accept)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strpbrk (char *__s, const char *__accept) noexcept (true)
{
  return __builtin_strpbrk (__s, __accept);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strpbrk (const char *__s, const char *__accept) noexcept (true)
{
  return __builtin_strpbrk (__s, __accept);
}

}






extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strstr (char *__haystack, const char *__needle) noexcept (true)
{
  return __builtin_strstr (__haystack, __needle);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strstr (const char *__haystack, const char *__needle) noexcept (true)
{
  return __builtin_strstr (__haystack, __needle);
}

}







extern char *strtok (char *__restrict __s, const char *__restrict __delim)
     noexcept (true) __attribute__ ((__nonnull__ (2)));



extern char *__strtok_r (char *__restrict __s,
    const char *__restrict __delim,
    char **__restrict __save_ptr)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
         char **__restrict __save_ptr)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, const char *__needle)
     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
         const char *__needle)
     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 389 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
       const void *__needle, size_t __needlelen)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)))

                                         ;



extern void *__mempcpy (void *__restrict __dest,
   const void *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        const void *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern size_t strlen (const char *__s)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern size_t strnlen (const char *__string, size_t __maxlen)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern char *strerror (int __errnum) noexcept (true);
# 444 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;




extern const char *strerrordesc_np (int __err) noexcept (true);

extern const char *strerrorname_np (int __err) noexcept (true);





extern char *strerror_l (int __errnum, locale_t __l) noexcept (true);



# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 24 "/usr/include/strings.h" 2 3 4






extern "C" {



extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void bcopy (const void *__src, void *__dest, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 68 "/usr/include/strings.h" 3 4
extern char *index (const char *__s, int __c)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 96 "/usr/include/strings.h" 3 4
extern char *rindex (const char *__s, int __c)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));






extern int ffs (int __i) noexcept (true) __attribute__ ((__const__));





extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
     noexcept (true) __attribute__ ((__const__));



extern int strcasecmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));



extern int strncasecmp_l (const char *__s1, const char *__s2,
     size_t __n, locale_t __loc)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));


}
# 463 "/usr/include/string.h" 2 3 4



extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                  ;



extern char *strsep (char **__restrict __stringp,
       const char *__restrict __delim)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) noexcept (true);



extern const char *sigabbrev_np (int __sig) noexcept (true);


extern const char *sigdescr_np (int __sig) noexcept (true);



extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                          ;







extern "C++" char *basename (char *__filename)
     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 539 "/usr/include/string.h" 3 4
}
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstring" 2 3
# 74 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstring" 3
}
}
# 7 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/strtok.h" 2 3


inline char *R__STRTOK_R(char *str, const char *delim, char **saveptr)
{



   return strtok_r(str, delim, saveptr);

}
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/strlcpy.h" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/strlcpy.h" 3
# 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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3 4
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3 4
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3 4
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3 4
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3 4
# 227 "/usr/include/unistd.h" 2 3 4
# 274 "/usr/include/unistd.h" 3 4
typedef __socklen_t socklen_t;
# 287 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int euidaccess (const char *__name, int __type)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int eaccess (const char *__name, int __type)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int execveat (int __fd, const char *__path, char *const __argv[],
                     char *const __envp[], int __flags)
    noexcept (true) __attribute__ ((__nonnull__ (2, 3)));






extern int faccessat (int __fd, const char *__file, int __type, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;
# 339 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) noexcept (true);
# 350 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     noexcept (true);






extern int close (int __fd);




extern void closefrom (int __lowfd) noexcept (true);







extern ssize_t read (int __fd, void *__buf, size_t __nbytes)
                                                  ;





extern ssize_t write (int __fd, const void *__buf, size_t __n)
                                         ;
# 389 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset)
                                                  ;






extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
         __off_t __offset)
                                         ;
# 422 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset)
                                                  ;


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
    __off64_t __offset)
                                         ;







extern int pipe (int __pipedes[2]) noexcept (true) ;




extern int pipe2 (int __pipedes[2], int __flags) noexcept (true) ;
# 452 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) noexcept (true);
# 464 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     noexcept (true);






extern int usleep (__useconds_t __useconds);
# 489 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) noexcept (true) ;




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;






extern int fchownat (int __fd, const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;



extern int chdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int fchdir (int __fd) noexcept (true) ;
# 531 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) noexcept (true) ;





extern char *get_current_dir_name (void) noexcept (true);







extern char *getwd (char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__))
                                       ;




extern int dup (int __fd) noexcept (true) ;


extern int dup2 (int __fd, int __fd2) noexcept (true);




extern int dup3 (int __fd, int __fd2, int __flags) noexcept (true);



extern char **__environ;

extern char **environ;





extern int execve (const char *__path, char *const __argv[],
     char *const __envp[]) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
     noexcept (true) __attribute__ ((__nonnull__ (2)));




extern int execv (const char *__path, char *const __argv[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execle (const char *__path, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execl (const char *__path, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execvp (const char *__file, char *const __argv[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int execlp (const char *__file, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int execvpe (const char *__file, char *const __argv[],
      char *const __envp[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern int nice (int __inc) noexcept (true) ;




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 24 "/usr/include/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX,

    _PC_2_SYMLINKS

  };


enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,




    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_IOV_MAX = _SC_UIO_MAXIOV,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,



    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG,


    _SC_LEVEL1_ICACHE_SIZE,

    _SC_LEVEL1_ICACHE_ASSOC,

    _SC_LEVEL1_ICACHE_LINESIZE,

    _SC_LEVEL1_DCACHE_SIZE,

    _SC_LEVEL1_DCACHE_ASSOC,

    _SC_LEVEL1_DCACHE_LINESIZE,

    _SC_LEVEL2_CACHE_SIZE,

    _SC_LEVEL2_CACHE_ASSOC,

    _SC_LEVEL2_CACHE_LINESIZE,

    _SC_LEVEL3_CACHE_SIZE,

    _SC_LEVEL3_CACHE_ASSOC,

    _SC_LEVEL3_CACHE_LINESIZE,

    _SC_LEVEL4_CACHE_SIZE,

    _SC_LEVEL4_CACHE_ASSOC,

    _SC_LEVEL4_CACHE_LINESIZE,



    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,

    _SC_RAW_SOCKETS,


    _SC_V7_ILP32_OFF32,

    _SC_V7_ILP32_OFFBIG,

    _SC_V7_LP64_OFF64,

    _SC_V7_LPBIG_OFFBIG,


    _SC_SS_REPL_MAX,


    _SC_TRACE_EVENT_NAME_MAX,

    _SC_TRACE_NAME_MAX,

    _SC_TRACE_SYS_MAX,

    _SC_TRACE_USER_EVENT_MAX,


    _SC_XOPEN_STREAMS,


    _SC_THREAD_ROBUST_PRIO_INHERIT,

    _SC_THREAD_ROBUST_PRIO_PROTECT,


    _SC_MINSIGSTKSZ,


    _SC_SIGSTKSZ

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,



    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _CS_V5_WIDTH_RESTRICTED_ENVS,



    _CS_V7_WIDTH_RESTRICTED_ENVS,



    _CS_LFS_CFLAGS = 1000,

    _CS_LFS_LDFLAGS,

    _CS_LFS_LIBS,

    _CS_LFS_LINTFLAGS,

    _CS_LFS64_CFLAGS,

    _CS_LFS64_LDFLAGS,

    _CS_LFS64_LIBS,

    _CS_LFS64_LINTFLAGS,


    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,

    _CS_XBS5_ILP32_OFF32_LDFLAGS,

    _CS_XBS5_ILP32_OFF32_LIBS,

    _CS_XBS5_ILP32_OFF32_LINTFLAGS,

    _CS_XBS5_ILP32_OFFBIG_CFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LIBS,

    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,

    _CS_XBS5_LP64_OFF64_CFLAGS,

    _CS_XBS5_LP64_OFF64_LDFLAGS,

    _CS_XBS5_LP64_OFF64_LIBS,

    _CS_XBS5_LP64_OFF64_LINTFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LIBS,

    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LIBS,

    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V6_LP64_OFF64_CFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LIBS,

    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LIBS,

    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V7_LP64_OFF64_CFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LIBS,

    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,


    _CS_V6_ENV,

    _CS_V7_ENV

  };
# 631 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (const char *__path, int __name)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) noexcept (true);


extern long int sysconf (int __name) noexcept (true);



extern size_t confstr (int __name, char *__buf, size_t __len) noexcept (true)
                                                  ;




extern __pid_t getpid (void) noexcept (true);


extern __pid_t getppid (void) noexcept (true);


extern __pid_t getpgrp (void) noexcept (true);


extern __pid_t __getpgid (__pid_t __pid) noexcept (true);

extern __pid_t getpgid (__pid_t __pid) noexcept (true);






extern int setpgid (__pid_t __pid, __pid_t __pgid) noexcept (true);
# 682 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) noexcept (true);






extern __pid_t setsid (void) noexcept (true);



extern __pid_t getsid (__pid_t __pid) noexcept (true);



extern __uid_t getuid (void) noexcept (true);


extern __uid_t geteuid (void) noexcept (true);


extern __gid_t getgid (void) noexcept (true);


extern __gid_t getegid (void) noexcept (true);




extern int getgroups (int __size, __gid_t __list[]) noexcept (true)
                                                  ;


extern int group_member (__gid_t __gid) noexcept (true);






extern int setuid (__uid_t __uid) noexcept (true) ;




extern int setreuid (__uid_t __ruid, __uid_t __euid) noexcept (true) ;




extern int seteuid (__uid_t __uid) noexcept (true) ;






extern int setgid (__gid_t __gid) noexcept (true) ;




extern int setregid (__gid_t __rgid, __gid_t __egid) noexcept (true) ;




extern int setegid (__gid_t __gid) noexcept (true) ;





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     noexcept (true);



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     noexcept (true);



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     noexcept (true) ;



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     noexcept (true) ;






extern __pid_t fork (void) noexcept (true);







extern __pid_t vfork (void) noexcept (true);






extern __pid_t _Fork (void) noexcept (true);





extern char *ttyname (int __fd) noexcept (true);



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2)))
                                                   ;



extern int isatty (int __fd) noexcept (true);




extern int ttyslot (void) noexcept (true);




extern int link (const char *__from, const char *__to)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern int linkat (int __fromfd, const char *__from, int __tofd,
     const char *__to, int __flags)
     noexcept (true) __attribute__ ((__nonnull__ (2, 4))) ;




extern int symlink (const char *__from, const char *__to)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern ssize_t readlink (const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)))
                                                   ;





extern int symlinkat (const char *__from, int __tofd,
        const char *__to) noexcept (true) __attribute__ ((__nonnull__ (1, 3))) ;


extern ssize_t readlinkat (int __fd, const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)))
                                                   ;



extern int unlink (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int unlinkat (int __fd, const char *__name, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2)));



extern int rmdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) noexcept (true);


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) noexcept (true);






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)))
                                                  ;




extern int setlogin (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));







# 1 "/usr/include/bits/getopt_posix.h" 1 3 4
# 27 "/usr/include/bits/getopt_posix.h" 3 4
# 1 "/usr/include/bits/getopt_core.h" 1 3 4
# 28 "/usr/include/bits/getopt_core.h" 3 4
extern "C" {







extern char *optarg;
# 50 "/usr/include/bits/getopt_core.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 91 "/usr/include/bits/getopt_core.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       noexcept (true) __attribute__ ((__nonnull__ (2, 3)));

}
# 28 "/usr/include/bits/getopt_posix.h" 2 3 4

extern "C" {
# 49 "/usr/include/bits/getopt_posix.h" 3 4
}
# 904 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                  ;






extern int sethostname (const char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int sethostid (long int __id) noexcept (true) ;





extern int getdomainname (char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                   ;
extern int setdomainname (const char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern int vhangup (void) noexcept (true);


extern int revoke (const char *__file) noexcept (true) __attribute__ ((__nonnull__ (1))) ;







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int acct (const char *__name) noexcept (true);



extern char *getusershell (void) noexcept (true);
extern void endusershell (void) noexcept (true);
extern void setusershell (void) noexcept (true);





extern int daemon (int __nochdir, int __noclose) noexcept (true) ;






extern int chroot (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));







extern int fsync (int __fd);





extern int syncfs (int __fd) noexcept (true);






extern long int gethostid (void);


extern void sync (void) noexcept (true);





extern int getpagesize (void) noexcept (true) __attribute__ ((__const__));




extern int getdtablesize (void) noexcept (true);
# 1026 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 1038 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 1049 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) noexcept (true) ;
# 1059 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) noexcept (true) ;
# 1070 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) noexcept (true) ;





extern void *sbrk (intptr_t __delta) noexcept (true);
# 1091 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) noexcept (true);
# 1114 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1124 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1142 "/usr/include/unistd.h" 3 4
ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
    int __outfd, __off64_t *__poutoff,
    size_t __length, unsigned int __flags);





extern int fdatasync (int __fildes);
# 1159 "/usr/include/unistd.h" 3 4
extern char *crypt (const char *__key, const char *__salt)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));







extern void swab (const void *__restrict __from, void *__restrict __to,
    ssize_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)))

                                          ;
# 1198 "/usr/include/unistd.h" 3 4
int getentropy (void *__buffer, size_t __length)
                                          ;
# 1208 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/unistd_ext.h" 1 3 4
# 34 "/usr/include/bits/unistd_ext.h" 3 4
extern __pid_t gettid (void) noexcept (true);



# 1 "/usr/include/linux/close_range.h" 1 3 4
# 39 "/usr/include/bits/unistd_ext.h" 2 3 4
# 56 "/usr/include/bits/unistd_ext.h" 3 4
extern int close_range (unsigned int __fd, unsigned int __max_fd,
   int __flags) noexcept (true);
# 1209 "/usr/include/unistd.h" 2 3 4

}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/strlcpy.h" 2 3





extern "C" {


size_t strlcpy(char *dst, const char *src, size_t siz);
size_t strlcat(char *dst, const char *src, size_t siz);


}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/snprintf.h" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 1 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_lockfree_defines.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 2 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/climits" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/climits" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/limits.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/limits.h" 3
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4
# 195 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 27 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/posix1_lim.h" 2 3 4
# 161 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 38 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 2 3 4
# 162 "/usr/include/bits/posix1_lim.h" 2 3 4
# 196 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 200 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 64 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/uio_lim.h" 1 3 4
# 65 "/usr/include/bits/xopen_lim.h" 2 3 4
# 204 "/usr/include/limits.h" 2 3 4
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/limits.h" 2 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/climits" 2 3

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/climits" 3
#pragma GCC diagnostic pop
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 2 3

# 1 "/usr/include/syscall.h" 1 3 4
# 1 "/usr/include/sys/syscall.h" 1 3 4
# 24 "/usr/include/sys/syscall.h" 3 4
# 1 "/usr/include/asm/unistd.h" 1 3 4
# 20 "/usr/include/asm/unistd.h" 3 4
# 1 "/usr/include/asm/unistd_64.h" 1 3 4
# 21 "/usr/include/asm/unistd.h" 2 3 4
# 25 "/usr/include/sys/syscall.h" 2 3 4




# 1 "/usr/include/bits/syscall.h" 1 3 4
# 30 "/usr/include/sys/syscall.h" 2 3 4
# 2 "/usr/include/syscall.h" 2 3 4
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 3
  class __mutex_base
  {
  protected:
    typedef __gthread_mutex_t __native_type;


    __native_type _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } };

    constexpr __mutex_base() noexcept = default;
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 3
    __mutex_base(const __mutex_base&) = delete;
    __mutex_base& operator=(const __mutex_base&) = delete;
  };
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 3
  class mutex : private __mutex_base
  {
  public:
    typedef __native_type* native_handle_type;


    constexpr

    mutex() noexcept = default;
    ~mutex() = default;

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_mutex_trylock(&_M_mutex);
    }

    void
    unlock()
    {

      __gthread_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };




  class __condvar
  {
    using timespec = __gthread_time_t;

  public:
    __condvar() noexcept
    {



    }

    ~__condvar()
    {
      int __e __attribute__((__unused__)) = __gthread_cond_destroy(&_M_cond);
      do { if (std::__is_constant_evaluated() && !bool(__e != 16)) std::__glibcxx_assert_fail(); } while (false);
    }

    __condvar(const __condvar&) = delete;
    __condvar& operator=(const __condvar&) = delete;

    __gthread_cond_t* native_handle() noexcept { return &_M_cond; }


    void
    wait(mutex& __m)
    {
      int __e __attribute__((__unused__))
 = __gthread_cond_wait(&_M_cond, __m.native_handle());
      do { if (std::__is_constant_evaluated() && !bool(__e == 0)) std::__glibcxx_assert_fail(); } while (false);
    }

    void
    wait_until(mutex& __m, timespec& __abs_time)
    {
      __gthread_cond_timedwait(&_M_cond, __m.native_handle(), &__abs_time);
    }


    void
    wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time)
    {
      pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock,
        &__abs_time);
    }


    void
    notify_one() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_signal(&_M_cond);
      do { if (std::__is_constant_evaluated() && !bool(__e == 0)) std::__glibcxx_assert_fail(); } while (false);
    }

    void
    notify_all() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_broadcast(&_M_cond);
      do { if (std::__is_constant_evaluated() && !bool(__e == 0)) std::__glibcxx_assert_fail(); } while (false);
    }

  protected:

    __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };



  };





  struct defer_lock_t { explicit defer_lock_t() = default; };


  struct try_to_lock_t { explicit try_to_lock_t() = default; };



  struct adopt_lock_t { explicit adopt_lock_t() = default; };


  inline constexpr defer_lock_t defer_lock { };


  inline constexpr try_to_lock_t try_to_lock { };


  inline constexpr adopt_lock_t adopt_lock { };
# 244 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_mutex.h" 3
  template<typename _Mutex>
    class lock_guard
    {
    public:
      typedef _Mutex mutex_type;

      [[__nodiscard__]]
      explicit lock_guard(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      [[__nodiscard__]]
      lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m)
      { }

      ~lock_guard()
      { _M_device.unlock(); }

      lock_guard(const lock_guard&) = delete;
      lock_guard& operator=(const lock_guard&) = delete;

    private:
      mutex_type& _M_device;
    };



}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace __detail
  {


    using __platform_wait_t = int;
    inline constexpr size_t __platform_wait_alignment = 4;
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 3
  }

  template<typename _Tp>
    inline constexpr bool __platform_wait_uses_type

      = is_scalar_v<_Tp>
 && ((sizeof(_Tp) == sizeof(__detail::__platform_wait_t))
 && (alignof(_Tp*) >= __detail::__platform_wait_alignment));




  namespace __detail
  {

    enum class __futex_wait_flags : int
    {



      __private_flag = 0,

      __wait = 0,
      __wake = 1,
      __wait_bitset = 9,
      __wake_bitset = 10,
      __wait_private = __wait | __private_flag,
      __wake_private = __wake | __private_flag,
      __wait_bitset_private = __wait_bitset | __private_flag,
      __wake_bitset_private = __wake_bitset | __private_flag,
      __bitset_match_any = -1
    };

    template<typename _Tp>
      void
      __platform_wait(const _Tp* __addr, __platform_wait_t __val) noexcept
      {
 auto __e = syscall (202, static_cast<const void*>(__addr),
       static_cast<int>(__futex_wait_flags::__wait_private),
       __val, nullptr);
 if (!__e || (*__errno_location ()) == 11)
   return;
 if ((*__errno_location ()) != 4)
   __throw_system_error((*__errno_location ()));
      }

    template<typename _Tp>
      void
      __platform_notify(const _Tp* __addr, bool __all) noexcept
      {
 syscall (202, static_cast<const void*>(__addr),
   static_cast<int>(__futex_wait_flags::__wake_private),
   __all ? 2147483647 : 1);
      }


    inline void
    __thread_yield() noexcept
    {

     __gthread_yield();

    }

    inline void
    __thread_relax() noexcept
    {

      __builtin_ia32_pause();



    }

    inline constexpr auto __atomic_spin_count_relax = 12;
    inline constexpr auto __atomic_spin_count = 16;

    struct __default_spin_policy
    {
      bool
      operator()() const noexcept
      { return false; }
    };

    template<typename _Pred,
      typename _Spin = __default_spin_policy>
      bool
      __atomic_spin(_Pred& __pred, _Spin __spin = _Spin{ }) noexcept
      {
 for (auto __i = 0; __i < __atomic_spin_count; ++__i)
   {
     if (__pred())
       return true;

     if (__i < __atomic_spin_count_relax)
       __detail::__thread_relax();
     else
       __detail::__thread_yield();
   }

 while (__spin())
   {
     if (__pred())
       return true;
   }

 return false;
      }


    template<typename _Tp>
      bool __atomic_compare(const _Tp& __a, const _Tp& __b)
      {

 return __builtin_memcmp(&__a, &__b, sizeof(_Tp)) == 0;
      }

    struct __waiter_pool_base
    {


      static constexpr auto _S_align = 64;

      alignas(_S_align) __platform_wait_t _M_wait = 0;





      alignas(_S_align) __platform_wait_t _M_ver = 0;




      __waiter_pool_base() = default;

      void
      _M_enter_wait() noexcept
      { __atomic_fetch_add(&_M_wait, 1, 5); }

      void
      _M_leave_wait() noexcept
      { __atomic_fetch_sub(&_M_wait, 1, 3); }

      bool
      _M_waiting() const noexcept
      {
 __platform_wait_t __res;
 __atomic_load(&_M_wait, &__res, 5);
 return __res != 0;
      }

      void
      _M_notify(__platform_wait_t* __addr, [[maybe_unused]] bool __all,
  bool __bare) noexcept
      {

 if (__addr == &_M_ver)
   {
     __atomic_fetch_add(__addr, 1, 5);
     __all = true;
   }

 if (__bare || _M_waiting())
   __platform_notify(__addr, __all);
# 250 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 3
      }

      static __waiter_pool_base&
      _S_for(const void* __addr) noexcept
      {
 constexpr long unsigned int __ct = 16;
 static __waiter_pool_base __w[__ct];
 auto __key = ((long unsigned int)__addr >> 2) % __ct;
 return __w[__key];
      }
    };

    struct __waiter_pool : __waiter_pool_base
    {
      void
      _M_do_wait(const __platform_wait_t* __addr, __platform_wait_t __old) noexcept
      {

 __platform_wait(__addr, __old);
# 280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_wait.h" 3
      }
    };

    template<typename _Tp>
      struct __waiter_base
      {
 using __waiter_type = _Tp;

 __waiter_type& _M_w;
 __platform_wait_t* _M_addr;

 template<typename _Up>
   static __platform_wait_t*
   _S_wait_addr(const _Up* __a, __platform_wait_t* __b)
   {
     if constexpr (__platform_wait_uses_type<_Up>)
       return reinterpret_cast<__platform_wait_t*>(const_cast<_Up*>(__a));
     else
       return __b;
   }

 static __waiter_type&
 _S_for(const void* __addr) noexcept
 {
   static_assert(sizeof(__waiter_type) == sizeof(__waiter_pool_base));
   auto& res = __waiter_pool_base::_S_for(__addr);
   return reinterpret_cast<__waiter_type&>(res);
 }

 template<typename _Up>
   explicit __waiter_base(const _Up* __addr) noexcept
     : _M_w(_S_for(__addr))
     , _M_addr(_S_wait_addr(__addr, &_M_w._M_ver))
   { }

 void
 _M_notify(bool __all, bool __bare = false) noexcept
 { _M_w._M_notify(_M_addr, __all, __bare); }

 template<typename _Up, typename _ValFn,
   typename _Spin = __default_spin_policy>
   static bool
   _S_do_spin_v(__platform_wait_t* __addr,
         const _Up& __old, _ValFn __vfn,
         __platform_wait_t& __val,
         _Spin __spin = _Spin{ })
   {
     auto const __pred = [=]
       { return !__detail::__atomic_compare(__old, __vfn()); };

     if constexpr (__platform_wait_uses_type<_Up>)
       {
  __builtin_memcpy(&__val, &__old, sizeof(__val));
       }
     else
       {
  __atomic_load(__addr, &__val, 2);
       }
     return __atomic_spin(__pred, __spin);
   }

 template<typename _Up, typename _ValFn,
   typename _Spin = __default_spin_policy>
   bool
   _M_do_spin_v(const _Up& __old, _ValFn __vfn,
         __platform_wait_t& __val,
         _Spin __spin = _Spin{ })
   { return _S_do_spin_v(_M_addr, __old, __vfn, __val, __spin); }

 template<typename _Pred,
   typename _Spin = __default_spin_policy>
   static bool
   _S_do_spin(const __platform_wait_t* __addr,
       _Pred __pred,
       __platform_wait_t& __val,
       _Spin __spin = _Spin{ })
   {
     __atomic_load(__addr, &__val, 2);
     return __atomic_spin(__pred, __spin);
   }

 template<typename _Pred,
   typename _Spin = __default_spin_policy>
   bool
   _M_do_spin(_Pred __pred, __platform_wait_t& __val,
       _Spin __spin = _Spin{ })
   { return _S_do_spin(_M_addr, __pred, __val, __spin); }
      };

    template<typename _EntersWait>
      struct __waiter : __waiter_base<__waiter_pool>
      {
 using __base_type = __waiter_base<__waiter_pool>;

 template<typename _Tp>
   explicit __waiter(const _Tp* __addr) noexcept
     : __base_type(__addr)
   {
     if constexpr (_EntersWait::value)
       _M_w._M_enter_wait();
   }

 ~__waiter()
 {
   if constexpr (_EntersWait::value)
     _M_w._M_leave_wait();
 }

 template<typename _Tp, typename _ValFn>
   void
   _M_do_wait_v(_Tp __old, _ValFn __vfn)
   {
     do
       {
  __platform_wait_t __val;
  if (__base_type::_M_do_spin_v(__old, __vfn, __val))
    return;
  __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val);
       }
     while (__detail::__atomic_compare(__old, __vfn()));
   }

 template<typename _Pred>
   void
   _M_do_wait(_Pred __pred) noexcept
   {
     do
       {
  __platform_wait_t __val;
  if (__base_type::_M_do_spin(__pred, __val))
    return;
  __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val);
       }
     while (!__pred());
   }
      };

    using __enters_wait = __waiter<std::true_type>;
    using __bare_wait = __waiter<std::false_type>;
  }

  template<typename _Tp, typename _ValFn>
    void
    __atomic_wait_address_v(const _Tp* __addr, _Tp __old,
       _ValFn __vfn) noexcept
    {
      __detail::__enters_wait __w(__addr);
      __w._M_do_wait_v(__old, __vfn);
    }

  template<typename _Tp, typename _Pred>
    void
    __atomic_wait_address(const _Tp* __addr, _Pred __pred) noexcept
    {
      __detail::__enters_wait __w(__addr);
      __w._M_do_wait(__pred);
    }


  template<typename _Pred>
    void
    __atomic_wait_address_bare(const __detail::__platform_wait_t* __addr,
          _Pred __pred) noexcept
    {

      do
 {
   __detail::__platform_wait_t __val;
   if (__detail::__bare_wait::_S_do_spin(__addr, __pred, __val))
     return;
   __detail::__platform_wait(__addr, __val);
 }
      while (!__pred());




    }

  template<typename _Tp>
    void
    __atomic_notify_address(const _Tp* __addr, bool __all) noexcept
    {
      __detail::__bare_wait __w(__addr);
      __w._M_notify(__all);
    }


  inline void
  __atomic_notify_address_bare(const __detail::__platform_wait_t* __addr,
          bool __all) noexcept
  {

    __detail::__platform_notify(__addr, __all);




  }

}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
  enum class memory_order : int
    {
      relaxed,
      consume,
      acquire,
      release,
      acq_rel,
      seq_cst
    };

  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
  inline constexpr memory_order memory_order_consume = memory_order::consume;
  inline constexpr memory_order memory_order_acquire = memory_order::acquire;
  inline constexpr memory_order memory_order_release = memory_order::release;
  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
  enum __memory_order_modifier
    {
      __memory_order_mask = 0x0ffff,
      __memory_order_modifier_mask = 0xffff0000,
      __memory_order_hle_acquire = 0x10000,
      __memory_order_hle_release = 0x20000
    };


  constexpr memory_order
  operator|(memory_order __m, __memory_order_modifier __mod) noexcept
  {
    return memory_order(int(__m) | int(__mod));
  }

  constexpr memory_order
  operator&(memory_order __m, __memory_order_modifier __mod) noexcept
  {
    return memory_order(int(__m) & int(__mod));
  }




  constexpr memory_order
  __cmpexch_failure_order2(memory_order __m) noexcept
  {
    return __m == memory_order_acq_rel ? memory_order_acquire
      : __m == memory_order_release ? memory_order_relaxed : __m;
  }

  constexpr memory_order
  __cmpexch_failure_order(memory_order __m) noexcept
  {
    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
      | __memory_order_modifier(__m & __memory_order_modifier_mask));
  }

  constexpr bool
  __is_valid_cmpexch_failure_order(memory_order __m) noexcept
  {
    return (__m & __memory_order_mask) != memory_order_release
 && (__m & __memory_order_mask) != memory_order_acq_rel;
  }


  template<typename _IntTp>
    struct __atomic_base;



  inline __attribute__((__always_inline__)) void
  atomic_thread_fence(memory_order __m) noexcept
  { __atomic_thread_fence(int(__m)); }

  inline __attribute__((__always_inline__)) void
  atomic_signal_fence(memory_order __m) noexcept
  { __atomic_signal_fence(int(__m)); }


  template<typename _Tp>
    inline _Tp
    kill_dependency(_Tp __y) noexcept
    {
      _Tp __ret(__y);
      return __ret;
    }
# 172 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
  template<typename _Tp>
    struct atomic;

  template<typename _Tp>
    struct atomic<_Tp*>;



    typedef bool __atomic_flag_data_type;
# 197 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
  extern "C" {

  struct __atomic_flag_base
  {
    __atomic_flag_data_type _M_i = {};
  };

  }






  struct atomic_flag : public __atomic_flag_base
  {
    atomic_flag() noexcept = default;
    ~atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;


    constexpr atomic_flag(bool __i) noexcept
      : __atomic_flag_base{ _S_init(__i) }
    { }

    inline __attribute__((__always_inline__)) bool
    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
    {
      return __atomic_test_and_set (&_M_i, int(__m));
    }

    inline __attribute__((__always_inline__)) bool
    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
    {
      return __atomic_test_and_set (&_M_i, int(__m));
    }


    inline __attribute__((__always_inline__)) bool
    test(memory_order __m = memory_order_seq_cst) const noexcept
    {
      __atomic_flag_data_type __v;
      __atomic_load(&_M_i, &__v, int(__m));
      return __v == 1;
    }

    inline __attribute__((__always_inline__)) bool
    test(memory_order __m = memory_order_seq_cst) const volatile noexcept
    {
      __atomic_flag_data_type __v;
      __atomic_load(&_M_i, &__v, int(__m));
      return __v == 1;
    }



    inline __attribute__((__always_inline__)) void
    wait(bool __old,
 memory_order __m = memory_order_seq_cst) const noexcept
    {
      const __atomic_flag_data_type __v
 = __old ? 1 : 0;

      std::__atomic_wait_address_v(&_M_i, __v,
   [__m, this] { return __atomic_load_n(&_M_i, int(__m)); });
    }



    inline __attribute__((__always_inline__)) void
    notify_one() noexcept
    { std::__atomic_notify_address(&_M_i, false); }



    inline __attribute__((__always_inline__)) void
    notify_all() noexcept
    { std::__atomic_notify_address(&_M_i, true); }




    inline __attribute__((__always_inline__)) void
    clear(memory_order __m = memory_order_seq_cst) noexcept
    {
      memory_order __b __attribute__ ((__unused__))
 = __m & __memory_order_mask;
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

      __atomic_clear (&_M_i, int(__m));
    }

    inline __attribute__((__always_inline__)) void
    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
    {
      memory_order __b __attribute__ ((__unused__))
 = __m & __memory_order_mask;
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

      __atomic_clear (&_M_i, int(__m));
    }

  private:
    static constexpr __atomic_flag_data_type
    _S_init(bool __i)
    { return __i ? 1 : 0; }
  };
# 337 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
  template<typename _ITp>
    struct __atomic_base
    {
      using value_type = _ITp;
      using difference_type = value_type;

    private:
      typedef _ITp __int_type;

      static constexpr int _S_alignment =
 sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);

      alignas(_S_alignment) __int_type _M_i = 0;

    public:
      __atomic_base() noexcept = default;
      ~__atomic_base() noexcept = default;
      __atomic_base(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) volatile = delete;

      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }

      operator __int_type() const noexcept
      { return load(); }

      operator __int_type() const volatile noexcept
      { return load(); }

      __int_type
      operator=(__int_type __i) noexcept
      {
 store(__i);
 return __i;
      }

      __int_type
      operator=(__int_type __i) volatile noexcept
      {
 store(__i);
 return __i;
      }

      __int_type
      operator++(int) noexcept
      { return fetch_add(1); }

      __int_type
      operator++(int) volatile noexcept
      { return fetch_add(1); }

      __int_type
      operator--(int) noexcept
      { return fetch_sub(1); }

      __int_type
      operator--(int) volatile noexcept
      { return fetch_sub(1); }

      __int_type
      operator++() noexcept
      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator++() volatile noexcept
      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator--() noexcept
      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator--() volatile noexcept
      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator+=(__int_type __i) noexcept
      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator+=(__int_type __i) volatile noexcept
      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator-=(__int_type __i) noexcept
      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator-=(__int_type __i) volatile noexcept
      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator&=(__int_type __i) noexcept
      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator&=(__int_type __i) volatile noexcept
      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator|=(__int_type __i) noexcept
      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator|=(__int_type __i) volatile noexcept
      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator^=(__int_type __i) noexcept
      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator^=(__int_type __i) volatile noexcept
      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      inline __attribute__((__always_inline__)) void
      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);

 __atomic_store_n(&_M_i, __i, int(__m));
      }

      inline __attribute__((__always_inline__)) void
      store(__int_type __i,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);

 __atomic_store_n(&_M_i, __i, int(__m));
      }

      inline __attribute__((__always_inline__)) __int_type
      load(memory_order __m = memory_order_seq_cst) const noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_load_n(&_M_i, int(__m));
      }

      inline __attribute__((__always_inline__)) __int_type
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_load_n(&_M_i, int(__m));
      }

      inline __attribute__((__always_inline__)) __int_type
      exchange(__int_type __i,
        memory_order __m = memory_order_seq_cst) noexcept
      {
 return __atomic_exchange_n(&_M_i, __i, int(__m));
      }


      inline __attribute__((__always_inline__)) __int_type
      exchange(__int_type __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return __atomic_exchange_n(&_M_i, __i, int(__m));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__int_type& __i1, __int_type __i2,
       memory_order __m1, memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__int_type& __i1, __int_type __i2,
       memory_order __m1,
       memory_order __m2) volatile noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__int_type& __i1, __int_type __i2,
       memory_order __m = memory_order_seq_cst) noexcept
      {
 return compare_exchange_weak(__i1, __i2, __m,
         __cmpexch_failure_order(__m));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__int_type& __i1, __int_type __i2,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return compare_exchange_weak(__i1, __i2, __m,
         __cmpexch_failure_order(__m));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__int_type& __i1, __int_type __i2,
         memory_order __m1, memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__int_type& __i1, __int_type __i2,
         memory_order __m1,
         memory_order __m2) volatile noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__int_type& __i1, __int_type __i2,
         memory_order __m = memory_order_seq_cst) noexcept
      {
 return compare_exchange_strong(__i1, __i2, __m,
           __cmpexch_failure_order(__m));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__int_type& __i1, __int_type __i2,
   memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return compare_exchange_strong(__i1, __i2, __m,
           __cmpexch_failure_order(__m));
      }


      inline __attribute__((__always_inline__)) void
      wait(__int_type __old,
   memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_i, __old,
      [__m, this] { return this->load(__m); });
      }



      inline __attribute__((__always_inline__)) void
      notify_one() noexcept
      { std::__atomic_notify_address(&_M_i, false); }



      inline __attribute__((__always_inline__)) void
      notify_all() noexcept
      { std::__atomic_notify_address(&_M_i, true); }




      inline __attribute__((__always_inline__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }
    };



  template<typename _PTp>
    struct __atomic_base<_PTp*>
    {
    private:
      typedef _PTp* __pointer_type;

      __pointer_type _M_p = nullptr;

      static constexpr ptrdiff_t
      _S_type_size(ptrdiff_t __d)
      { 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, _S_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator++() volatile noexcept
      { return __atomic_add_fetch(&_M_p, _S_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator--() noexcept
      { return __atomic_sub_fetch(&_M_p, _S_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator--() volatile noexcept
      { return __atomic_sub_fetch(&_M_p, _S_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator+=(ptrdiff_t __d) noexcept
      { return __atomic_add_fetch(&_M_p, _S_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator+=(ptrdiff_t __d) volatile noexcept
      { return __atomic_add_fetch(&_M_p, _S_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator-=(ptrdiff_t __d) noexcept
      { return __atomic_sub_fetch(&_M_p, _S_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator-=(ptrdiff_t __d) volatile noexcept
      { return __atomic_sub_fetch(&_M_p, _S_type_size(__d),
      int(memory_order_seq_cst)); }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_p),
     reinterpret_cast<void *>(-__alignof(_M_p)));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_p),
     reinterpret_cast<void *>(-__alignof(_M_p)));
      }

      inline __attribute__((__always_inline__)) void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;

 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);

 __atomic_store_n(&_M_p, __p, int(__m));
      }

      inline __attribute__((__always_inline__)) void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) std::__glibcxx_assert_fail(); } while (false);

 __atomic_store_n(&_M_p, __p, int(__m));
      }

      inline __attribute__((__always_inline__)) __pointer_type
      load(memory_order __m = memory_order_seq_cst) const noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_load_n(&_M_p, int(__m));
      }

      inline __attribute__((__always_inline__)) __pointer_type
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_load_n(&_M_p, int(__m));
      }

      inline __attribute__((__always_inline__)) __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) noexcept
      {
 return __atomic_exchange_n(&_M_p, __p, int(__m));
      }


      inline __attribute__((__always_inline__)) __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return __atomic_exchange_n(&_M_p, __p, int(__m));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) volatile noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) volatile noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
        int(__m1), int(__m2));
      }


      inline __attribute__((__always_inline__)) void
      wait(__pointer_type __old,
    memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_p, __old,
         [__m, this]
         { return this->load(__m); });
      }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { std::__atomic_notify_address(&_M_p, false); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { std::__atomic_notify_address(&_M_p, true); }




      inline __attribute__((__always_inline__)) __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_add(&_M_p, _S_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, _S_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, _S_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, _S_type_size(__d), int(__m)); }
    };

  namespace __atomic_impl
  {


    template<typename _Tp>
      constexpr bool
      __maybe_has_padding()
      {

 return false;






      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) constexpr _Tp*
      __clear_padding(_Tp& __val) noexcept
      {
 auto* __ptr = std::__addressof(__val);




 return __ptr;
      }


    template<typename _Tp>
      using _Val = typename remove_volatile<_Tp>::type;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i,
    bool __is_weak,
    memory_order __s, memory_order __f) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) std::__glibcxx_assert_fail(); } while (false);

 using _Vp = _Val<_Tp>;
 _Tp* const __pval = std::__addressof(__val);

 if constexpr (!__atomic_impl::__maybe_has_padding<_Vp>())
   {
     return __atomic_compare_exchange(__pval, std::__addressof(__e),
          std::__addressof(__i), __is_weak,
          int(__s), int(__f));
   }
 else if constexpr (!_AtomicRef)
   {

     _Vp* const __pi = __atomic_impl::__clear_padding(__i);

     _Vp __exp = __e;

     _Vp* const __pexp = __atomic_impl::__clear_padding(__exp);



     if (__atomic_compare_exchange(__pval, __pexp, __pi,
       __is_weak, int(__s), int(__f)))
       return true;

     __builtin_memcpy(std::__addressof(__e), __pexp, sizeof(_Vp));
     return false;
   }
 else
   {

     _Vp* const __pi = __atomic_impl::__clear_padding(__i);


     _Vp __exp = __e;


     _Vp* const __pexp = __atomic_impl::__clear_padding(__exp);
# 1042 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_base.h" 3
     while (true)
       {

  _Vp __orig = __exp;

  if (__atomic_compare_exchange(__pval, __pexp, __pi,
           __is_weak, int(__s), int(__f)))
    return true;


  _Vp __curr = __exp;


  if (__builtin_memcmp(__atomic_impl::__clear_padding(__orig),
         __atomic_impl::__clear_padding(__curr),
         sizeof(_Vp)))
    {

      __builtin_memcpy(std::__addressof(__e), __pexp,
         sizeof(_Vp));
      return false;
    }
       }
   }
      }
#pragma GCC diagnostic pop
  }



  namespace __atomic_impl
  {

    template<typename _Tp>
      using _Diff = __conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>;

    template<size_t _Size, size_t _Align>
      inline __attribute__((__always_inline__)) bool
      is_lock_free() noexcept
      {

 return __atomic_is_lock_free(_Size, reinterpret_cast<void *>(-_Align));
      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept
      {
 __atomic_store(__ptr, __atomic_impl::__clear_padding(__t), int(__m));
      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Val<_Tp>
      load(const _Tp* __ptr, memory_order __m) noexcept
      {
 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf);
 __atomic_load(__ptr, __dest, int(__m));
 return *__dest;
      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Val<_Tp>
      exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m) noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf);
 __atomic_exchange(__ptr, __atomic_impl::__clear_padding(__desired),
     __dest, int(__m));
 return *__dest;
      }

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected,
       _Val<_Tp> __desired, memory_order __success,
       memory_order __failure) noexcept
      {
 return __atomic_impl::__compare_exchange<_AtomicRef>(
     *__ptr, __expected, __desired, true, __success, __failure);
      }

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected,
         _Val<_Tp> __desired, memory_order __success,
         memory_order __failure) noexcept
      {
 return __atomic_impl::__compare_exchange<_AtomicRef>(
     *__ptr, __expected, __desired, false, __success, __failure);
      }


    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      wait(const _Tp* __ptr, _Val<_Tp> __old,
    memory_order __m = memory_order_seq_cst) noexcept
      {
 std::__atomic_wait_address_v(__ptr, __old,
     [__ptr, __m]() { return __atomic_impl::load(__ptr, __m); });
      }



    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      notify_one(const _Tp* __ptr) noexcept
      { std::__atomic_notify_address(__ptr, false); }



    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      notify_all(const _Tp* __ptr) noexcept
      { std::__atomic_notify_address(__ptr, true); }




    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept
      { return __atomic_fetch_add(__ptr, __i, int(__m)); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept
      { return __atomic_fetch_sub(__ptr, __i, int(__m)); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept
      { return __atomic_fetch_and(__ptr, __i, int(__m)); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept
      { return __atomic_fetch_or(__ptr, __i, int(__m)); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept
      { return __atomic_fetch_xor(__ptr, __i, int(__m)); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept
      { return __atomic_add_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept
      { return __atomic_sub_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_and_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_or_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_xor_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      concept __atomic_fetch_addable
 = requires (_Tp __t) { __atomic_fetch_add(&__t, __t, 0); };

    template<typename _Tp>
      _Tp
      __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept
      {
 if constexpr (__atomic_fetch_addable<_Tp>)
   return __atomic_fetch_add(__ptr, __i, int(__m));
 else
   {
     _Val<_Tp> __oldval = load (__ptr, memory_order_relaxed);
     _Val<_Tp> __newval = __oldval + __i;
     while (!compare_exchange_weak (__ptr, __oldval, __newval, __m,
        memory_order_relaxed))
       __newval = __oldval + __i;
     return __oldval;
   }
      }

    template<typename _Tp>
      concept __atomic_fetch_subtractable
 = requires (_Tp __t) { __atomic_fetch_sub(&__t, __t, 0); };

    template<typename _Tp>
      _Tp
      __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept
      {
 if constexpr (__atomic_fetch_subtractable<_Tp>)
   return __atomic_fetch_sub(__ptr, __i, int(__m));
 else
   {
     _Val<_Tp> __oldval = load (__ptr, memory_order_relaxed);
     _Val<_Tp> __newval = __oldval - __i;
     while (!compare_exchange_weak (__ptr, __oldval, __newval, __m,
        memory_order_relaxed))
       __newval = __oldval - __i;
     return __oldval;
   }
      }

    template<typename _Tp>
      concept __atomic_add_fetchable
 = requires (_Tp __t) { __atomic_add_fetch(&__t, __t, 0); };

    template<typename _Tp>
      _Tp
      __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept
      {
 if constexpr (__atomic_add_fetchable<_Tp>)
   return __atomic_add_fetch(__ptr, __i, 5);
 else
   {
     _Val<_Tp> __oldval = load (__ptr, memory_order_relaxed);
     _Val<_Tp> __newval = __oldval + __i;
     while (!compare_exchange_weak (__ptr, __oldval, __newval,
        memory_order_seq_cst,
        memory_order_relaxed))
       __newval = __oldval + __i;
     return __newval;
   }
      }

    template<typename _Tp>
      concept __atomic_sub_fetchable
 = requires (_Tp __t) { __atomic_sub_fetch(&__t, __t, 0); };

    template<typename _Tp>
      _Tp
      __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept
      {
 if constexpr (__atomic_sub_fetchable<_Tp>)
   return __atomic_sub_fetch(__ptr, __i, 5);
 else
   {
     _Val<_Tp> __oldval = load (__ptr, memory_order_relaxed);
     _Val<_Tp> __newval = __oldval - __i;
     while (!compare_exchange_weak (__ptr, __oldval, __newval,
        memory_order_seq_cst,
        memory_order_relaxed))
       __newval = __oldval - __i;
     return __newval;
   }
      }
  }


  template<typename _Fp>
    struct __atomic_float
    {
      static_assert(is_floating_point_v<_Fp>);

      static constexpr size_t _S_alignment = __alignof__(_Fp);

    public:
      using value_type = _Fp;
      using difference_type = value_type;

      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_Fp), 0);

      __atomic_float() = default;

      constexpr
      __atomic_float(_Fp __t) : _M_fp(__t)
      { __atomic_impl::__clear_padding(_M_fp); }

      __atomic_float(const __atomic_float&) = delete;
      __atomic_float& operator=(const __atomic_float&) = delete;
      __atomic_float& operator=(const __atomic_float&) volatile = delete;

      _Fp
      operator=(_Fp __t) volatile noexcept
      {
 this->store(__t);
 return __t;
      }

      _Fp
      operator=(_Fp __t) noexcept
      {
 this->store(__t);
 return __t;
      }

      bool
      is_lock_free() const volatile noexcept
      { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); }

      bool
      is_lock_free() const noexcept
      { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); }

      void
      store(_Fp __t, memory_order __m = memory_order_seq_cst) volatile noexcept
      { __atomic_impl::store(&_M_fp, __t, __m); }

      void
      store(_Fp __t, memory_order __m = memory_order_seq_cst) noexcept
      { __atomic_impl::store(&_M_fp, __t, __m); }

      _Fp
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      { return __atomic_impl::load(&_M_fp, __m); }

      _Fp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::load(&_M_fp, __m); }

      operator _Fp() const volatile noexcept { return this->load(); }
      operator _Fp() const noexcept { return this->load(); }

      _Fp
      exchange(_Fp __desired,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_impl::exchange(&_M_fp, __desired, __m); }

      _Fp
      exchange(_Fp __desired,
        memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_impl::exchange(&_M_fp, __desired, __m); }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __success,
       memory_order __failure) noexcept
      {
 return __atomic_impl::compare_exchange_weak(&_M_fp,
          __expected, __desired,
          __success, __failure);
      }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __success,
       memory_order __failure) volatile noexcept
      {
 return __atomic_impl::compare_exchange_weak(&_M_fp,
          __expected, __desired,
          __success, __failure);
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __success,
         memory_order __failure) noexcept
      {
 return __atomic_impl::compare_exchange_strong(&_M_fp,
            __expected, __desired,
            __success, __failure);
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __success,
         memory_order __failure) volatile noexcept
      {
 return __atomic_impl::compare_exchange_strong(&_M_fp,
            __expected, __desired,
            __success, __failure);
      }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __order = memory_order_seq_cst)
      noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __order = memory_order_seq_cst)
      volatile noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __order = memory_order_seq_cst)
      noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __order = memory_order_seq_cst)
      volatile noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(&_M_fp, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(&_M_fp); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(&_M_fp); }




      value_type
      fetch_add(value_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); }

      value_type
      fetch_add(value_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); }

      value_type
      fetch_sub(value_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); }

      value_type
      fetch_sub(value_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); }

      value_type
      operator+=(value_type __i) noexcept
      { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); }

      value_type
      operator+=(value_type __i) volatile noexcept
      { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); }

      value_type
      operator-=(value_type __i) noexcept
      { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); }

      value_type
      operator-=(value_type __i) volatile noexcept
      { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); }

    private:
      alignas(_S_alignment) _Fp _M_fp = 0;
    };


  template<typename _Tp,
           bool = is_integral_v<_Tp> && !is_same_v<_Tp, bool>,
           bool = is_floating_point_v<_Tp>>
    struct __atomic_ref;


  template<typename _Tp>
    struct __atomic_ref<_Tp, false, false>
    {
      static_assert(is_trivially_copyable_v<_Tp>);


      static constexpr int _S_min_alignment
 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
 ? 0 : sizeof(_Tp);

    public:
      using value_type = _Tp;

      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_Tp), 0);

      static constexpr size_t required_alignment
 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);

      __atomic_ref& operator=(const __atomic_ref&) = delete;

      explicit
      __atomic_ref(_Tp& __t) : _M_ptr(std::__addressof(__t))
      {
 do { if (std::__is_constant_evaluated() && !bool(((long unsigned int)_M_ptr % required_alignment) == 0)) std::__glibcxx_assert_fail(); } while (false);
      }

      __atomic_ref(const __atomic_ref&) noexcept = default;

      _Tp
      operator=(_Tp __t) const noexcept
      {
 this->store(__t);
 return __t;
      }

      operator _Tp() const noexcept { return this->load(); }

      bool
      is_lock_free() const noexcept
      { return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>(); }

      void
      store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::store(_M_ptr, __t, __m); }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::load(_M_ptr, __m); }

      _Tp
      exchange(_Tp __desired, memory_order __m = memory_order_seq_cst)
      const noexcept
      { return __atomic_impl::exchange(_M_ptr, __desired, __m); }

      bool
      compare_exchange_weak(_Tp& __expected, _Tp __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_weak<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_strong(_Tp& __expected, _Tp __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_strong<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_weak(_Tp& __expected, _Tp __desired,
       memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Tp& __expected, _Tp __desired,
         memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




    private:
      _Tp* _M_ptr;
    };


  template<typename _Tp>
    struct __atomic_ref<_Tp, true, false>
    {
      static_assert(is_integral_v<_Tp>);

    public:
      using value_type = _Tp;
      using difference_type = value_type;

      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_Tp), 0);

      static constexpr size_t required_alignment
 = sizeof(_Tp) > alignof(_Tp) ? sizeof(_Tp) : alignof(_Tp);

      __atomic_ref() = delete;
      __atomic_ref& operator=(const __atomic_ref&) = delete;

      explicit
      __atomic_ref(_Tp& __t) : _M_ptr(&__t)
      {
 do { if (std::__is_constant_evaluated() && !bool(((long unsigned int)_M_ptr % required_alignment) == 0)) std::__glibcxx_assert_fail(); } while (false);
      }

      __atomic_ref(const __atomic_ref&) noexcept = default;

      _Tp
      operator=(_Tp __t) const noexcept
      {
 this->store(__t);
 return __t;
      }

      operator _Tp() const noexcept { return this->load(); }

      bool
      is_lock_free() const noexcept
      {
 return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>();
      }

      void
      store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::store(_M_ptr, __t, __m); }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::load(_M_ptr, __m); }

      _Tp
      exchange(_Tp __desired,
        memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::exchange(_M_ptr, __desired, __m); }

      bool
      compare_exchange_weak(_Tp& __expected, _Tp __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_weak<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_strong(_Tp& __expected, _Tp __desired,
         memory_order __success,
         memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_strong<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_weak(_Tp& __expected, _Tp __desired,
       memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Tp& __expected, _Tp __desired,
         memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      value_type
      fetch_add(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_add(_M_ptr, __i, __m); }

      value_type
      fetch_sub(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_sub(_M_ptr, __i, __m); }

      value_type
      fetch_and(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_and(_M_ptr, __i, __m); }

      value_type
      fetch_or(value_type __i,
        memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_or(_M_ptr, __i, __m); }

      value_type
      fetch_xor(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_xor(_M_ptr, __i, __m); }

      inline __attribute__((__always_inline__)) value_type
      operator++(int) const noexcept
      { return fetch_add(1); }

      inline __attribute__((__always_inline__)) value_type
      operator--(int) const noexcept
      { return fetch_sub(1); }

      value_type
      operator++() const noexcept
      { return __atomic_impl::__add_fetch(_M_ptr, value_type(1)); }

      value_type
      operator--() const noexcept
      { return __atomic_impl::__sub_fetch(_M_ptr, value_type(1)); }

      value_type
      operator+=(value_type __i) const noexcept
      { return __atomic_impl::__add_fetch(_M_ptr, __i); }

      value_type
      operator-=(value_type __i) const noexcept
      { return __atomic_impl::__sub_fetch(_M_ptr, __i); }

      value_type
      operator&=(value_type __i) const noexcept
      { return __atomic_impl::__and_fetch(_M_ptr, __i); }

      value_type
      operator|=(value_type __i) const noexcept
      { return __atomic_impl::__or_fetch(_M_ptr, __i); }

      value_type
      operator^=(value_type __i) const noexcept
      { return __atomic_impl::__xor_fetch(_M_ptr, __i); }

    private:
      _Tp* _M_ptr;
    };


  template<typename _Fp>
    struct __atomic_ref<_Fp, false, true>
    {
      static_assert(is_floating_point_v<_Fp>);

    public:
      using value_type = _Fp;
      using difference_type = value_type;

      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_Fp), 0);

      static constexpr size_t required_alignment = __alignof__(_Fp);

      __atomic_ref() = delete;
      __atomic_ref& operator=(const __atomic_ref&) = delete;

      explicit
      __atomic_ref(_Fp& __t) : _M_ptr(&__t)
      {
 do { if (std::__is_constant_evaluated() && !bool(((long unsigned int)_M_ptr % required_alignment) == 0)) std::__glibcxx_assert_fail(); } while (false);
      }

      __atomic_ref(const __atomic_ref&) noexcept = default;

      _Fp
      operator=(_Fp __t) const noexcept
      {
 this->store(__t);
 return __t;
      }

      operator _Fp() const noexcept { return this->load(); }

      bool
      is_lock_free() const noexcept
      {
 return __atomic_impl::is_lock_free<sizeof(_Fp), required_alignment>();
      }

      void
      store(_Fp __t, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::store(_M_ptr, __t, __m); }

      _Fp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::load(_M_ptr, __m); }

      _Fp
      exchange(_Fp __desired,
        memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::exchange(_M_ptr, __desired, __m); }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_weak<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __success,
         memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_strong<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_weak(_Fp& __expected, _Fp __desired,
       memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Fp& __expected, _Fp __desired,
         memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      value_type
      fetch_add(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::__fetch_add_flt(_M_ptr, __i, __m); }

      value_type
      fetch_sub(value_type __i,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::__fetch_sub_flt(_M_ptr, __i, __m); }

      value_type
      operator+=(value_type __i) const noexcept
      { return __atomic_impl::__add_fetch_flt(_M_ptr, __i); }

      value_type
      operator-=(value_type __i) const noexcept
      { return __atomic_impl::__sub_fetch_flt(_M_ptr, __i); }

    private:
      _Fp* _M_ptr;
    };


  template<typename _Tp>
    struct __atomic_ref<_Tp*, false, false>
    {
    public:
      using value_type = _Tp*;
      using difference_type = ptrdiff_t;

      static constexpr bool is_always_lock_free = 2 == 2;

      static constexpr size_t required_alignment = __alignof__(_Tp*);

      __atomic_ref() = delete;
      __atomic_ref& operator=(const __atomic_ref&) = delete;

      explicit
      __atomic_ref(_Tp*& __t) : _M_ptr(std::__addressof(__t))
      {
 do { if (std::__is_constant_evaluated() && !bool(((long unsigned int)_M_ptr % required_alignment) == 0)) std::__glibcxx_assert_fail(); } while (false);
      }

      __atomic_ref(const __atomic_ref&) noexcept = default;

      _Tp*
      operator=(_Tp* __t) const noexcept
      {
 this->store(__t);
 return __t;
      }

      operator _Tp*() const noexcept { return this->load(); }

      bool
      is_lock_free() const noexcept
      {
 return __atomic_impl::is_lock_free<sizeof(_Tp*), required_alignment>();
      }

      void
      store(_Tp* __t, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::store(_M_ptr, __t, __m); }

      _Tp*
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::load(_M_ptr, __m); }

      _Tp*
      exchange(_Tp* __desired,
        memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::exchange(_M_ptr, __desired, __m); }

      bool
      compare_exchange_weak(_Tp*& __expected, _Tp* __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_weak<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_strong(_Tp*& __expected, _Tp* __desired,
       memory_order __success,
       memory_order __failure) const noexcept
      {
 return __atomic_impl::compare_exchange_strong<true>(
   _M_ptr, __expected, __desired, __success, __failure);
      }

      bool
      compare_exchange_weak(_Tp*& __expected, _Tp* __desired,
       memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_weak(__expected, __desired, __order,
                                     __cmpexch_failure_order(__order));
      }

      bool
      compare_exchange_strong(_Tp*& __expected, _Tp* __desired,
         memory_order __order = memory_order_seq_cst)
      const noexcept
      {
 return compare_exchange_strong(__expected, __desired, __order,
           __cmpexch_failure_order(__order));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Tp* __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      inline __attribute__((__always_inline__)) value_type
      fetch_add(difference_type __d,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_add(_M_ptr, _S_type_size(__d), __m); }

      inline __attribute__((__always_inline__)) value_type
      fetch_sub(difference_type __d,
  memory_order __m = memory_order_seq_cst) const noexcept
      { return __atomic_impl::fetch_sub(_M_ptr, _S_type_size(__d), __m); }

      value_type
      operator++(int) const noexcept
      { return fetch_add(1); }

      value_type
      operator--(int) const noexcept
      { return fetch_sub(1); }

      value_type
      operator++() const noexcept
      {
 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(1));
      }

      value_type
      operator--() const noexcept
      {
 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(1));
      }

      value_type
      operator+=(difference_type __d) const noexcept
      {
 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(__d));
      }

      value_type
      operator-=(difference_type __d) const noexcept
      {
 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(__d));
      }

    private:
      static constexpr ptrdiff_t
      _S_type_size(ptrdiff_t __d) noexcept
      {
 static_assert(is_object_v<_Tp>);
 return __d * sizeof(_Tp);
      }

      _Tp** _M_ptr;
    };







}
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    struct atomic;



  template<>
  struct atomic<bool>
  {
    using value_type = bool;

  private:
    __atomic_base<bool> _M_base;

  public:
    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(bool __i) noexcept : _M_base(__i) { }

    bool
    operator=(bool __i) noexcept
    { return _M_base.operator=(__i); }

    bool
    operator=(bool __i) volatile noexcept
    { return _M_base.operator=(__i); }

    operator bool() const noexcept
    { return _M_base.load(); }

    operator bool() const volatile noexcept
    { return _M_base.load(); }

    bool
    is_lock_free() const noexcept { return _M_base.is_lock_free(); }

    bool
    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }


    static constexpr bool is_always_lock_free = 2 == 2;


    void
    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
    { _M_base.store(__i, __m); }

    void
    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
    { _M_base.store(__i, __m); }

    bool
    load(memory_order __m = memory_order_seq_cst) const noexcept
    { return _M_base.load(__m); }

    bool
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    { return _M_base.load(__m); }

    bool
    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.exchange(__i, __m); }

    bool
    exchange(bool __i,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.exchange(__i, __m); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     memory_order __m2) noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     memory_order __m2) volatile noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2,
     memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2,
       memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
       memory_order __m2) noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
       memory_order __m2) volatile noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2,
       memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }


    void
    wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept
    { _M_base.wait(__old, __m); }



    void
    notify_one() noexcept
    { _M_base.notify_one(); }

    void
    notify_all() noexcept
    { _M_base.notify_all(); }

  };






  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");


      static_assert(is_copy_constructible_v<_Tp>);
      static_assert(is_move_constructible_v<_Tp>);
      static_assert(is_copy_assignable_v<_Tp>);
      static_assert(is_move_assignable_v<_Tp>);


    public:



      constexpr atomic() noexcept(is_nothrow_default_constructible_v<_Tp>)
 requires is_default_constructible_v<_Tp>
 : _M_i()
      {}




      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(_Tp __i) noexcept : _M_i(__i)
      {




      }

      operator _Tp() const noexcept
      { return load(); }

      operator _Tp() const volatile noexcept
      { return load(); }

      _Tp
      operator=(_Tp __i) noexcept
      { store(__i); return __i; }

      _Tp
      operator=(_Tp __i) volatile noexcept
      { store(__i); return __i; }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }


      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_M_i), 0);


      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
      {
 __atomic_store(std::__addressof(_M_i),
         __atomic_impl::__clear_padding(__i),
         int(__m));
      }

      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 __atomic_store(std::__addressof(_M_i),
         __atomic_impl::__clear_padding(__i),
         int(__m));
      }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      {
 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_exchange(std::__addressof(_M_i),
     __atomic_impl::__clear_padding(__i),
     __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      exchange(_Tp __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_exchange(std::__addressof(_M_i),
     __atomic_impl::__clear_padding(__i),
     __ptr, int(__m));
 return *__ptr;
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true,
       __s, __f);
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) volatile noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true,
       __s, __f);
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) noexcept
      { return compare_exchange_weak(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) volatile noexcept
      { return compare_exchange_weak(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
         memory_order __f) noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, false,
       __s, __f);
      }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
         memory_order __f) volatile noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, false,
       __s, __f);
      }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i,
          memory_order __m = memory_order_seq_cst) noexcept
      { return compare_exchange_strong(__e, __i, __m,
                                       __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) volatile noexcept
      { return compare_exchange_strong(__e, __i, __m,
                                       __cmpexch_failure_order(__m)); }


      void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_i, __old,
      [__m, this] { return this->load(__m); });
      }



      void
      notify_one() noexcept
      { std::__atomic_notify_address(&_M_i, false); }

      void
      notify_all() noexcept
      { std::__atomic_notify_address(&_M_i, true); }


    };


  template<typename _Tp>
    struct atomic<_Tp*>
    {
      using value_type = _Tp*;
      using difference_type = ptrdiff_t;

      typedef _Tp* __pointer_type;
      typedef __atomic_base<_Tp*> __base_type;
      __base_type _M_b;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }

      operator __pointer_type() const noexcept
      { return __pointer_type(_M_b); }

      operator __pointer_type() const volatile noexcept
      { return __pointer_type(_M_b); }

      __pointer_type
      operator=(__pointer_type __p) noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator=(__pointer_type __p) volatile noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator++(int) noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator++(int) volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator--(int) noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator--(int) volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator++() noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator++() volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator--() noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator--() volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator+=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator+=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object_v<_Tp>, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      bool
      is_lock_free() const noexcept
      { return _M_b.is_lock_free(); }

      bool
      is_lock_free() const volatile noexcept
      { return _M_b.is_lock_free(); }


      static constexpr bool is_always_lock_free
 = 2 == 2;


      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.store(__p, __m); }

      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.store(__p, __m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return _M_b.load(__m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      { return _M_b.load(__m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.exchange(__p, __m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.exchange(__p, __m); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1, memory_order __m2) noexcept
      { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) volatile noexcept
      { return _M_b.compare_exchange_weak(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m = memory_order_seq_cst) noexcept
      {
 return compare_exchange_weak(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return compare_exchange_weak(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1, memory_order __m2) noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) volatile noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m = memory_order_seq_cst) noexcept
      {
 return _M_b.compare_exchange_strong(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return _M_b.compare_exchange_strong(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }


    void
    wait(__pointer_type __old, memory_order __m = memory_order_seq_cst) const noexcept
    { _M_b.wait(__old, __m); }



    void
    notify_one() noexcept
    { _M_b.notify_one(); }

    void
    notify_all() noexcept
    { _M_b.notify_all(); }


      __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      {

 static_assert( is_object_v<_Tp>, "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_v<_Tp>, "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_v<_Tp>, "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_v<_Tp>, "pointer to object type" );

 return _M_b.fetch_sub(__d, __m);
      }
    };



  template<>
    struct atomic<char> : __atomic_base<char>
    {
      typedef char __integral_type;
      typedef __atomic_base<char> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<signed char> : __atomic_base<signed char>
    {
      typedef signed char __integral_type;
      typedef __atomic_base<signed char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned char> : __atomic_base<unsigned char>
    {
      typedef unsigned char __integral_type;
      typedef __atomic_base<unsigned char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<short> : __atomic_base<short>
    {
      typedef short __integral_type;
      typedef __atomic_base<short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned short> : __atomic_base<unsigned short>
    {
      typedef unsigned short __integral_type;
      typedef __atomic_base<unsigned short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<int> : __atomic_base<int>
    {
      typedef int __integral_type;
      typedef __atomic_base<int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned int> : __atomic_base<unsigned int>
    {
      typedef unsigned int __integral_type;
      typedef __atomic_base<unsigned int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long> : __atomic_base<long>
    {
      typedef long __integral_type;
      typedef __atomic_base<long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long> : __atomic_base<unsigned long>
    {
      typedef unsigned long __integral_type;
      typedef __atomic_base<unsigned long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long long> : __atomic_base<long long>
    {
      typedef long long __integral_type;
      typedef __atomic_base<long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
    {
      typedef unsigned long long __integral_type;
      typedef __atomic_base<unsigned long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<wchar_t> : __atomic_base<wchar_t>
    {
      typedef wchar_t __integral_type;
      typedef __atomic_base<wchar_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };



  template<>
    struct atomic<char8_t> : __atomic_base<char8_t>
    {
      typedef char8_t __integral_type;
      typedef __atomic_base<char8_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };



  template<>
    struct atomic<char16_t> : __atomic_base<char16_t>
    {
      typedef char16_t __integral_type;
      typedef __atomic_base<char16_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };


  template<>
    struct atomic<char32_t> : __atomic_base<char32_t>
    {
      typedef char32_t __integral_type;
      typedef __atomic_base<char32_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };



  typedef atomic<bool> atomic_bool;


  typedef atomic<char> atomic_char;


  typedef atomic<signed char> atomic_schar;


  typedef atomic<unsigned char> atomic_uchar;


  typedef atomic<short> atomic_short;


  typedef atomic<unsigned short> atomic_ushort;


  typedef atomic<int> atomic_int;


  typedef atomic<unsigned int> atomic_uint;


  typedef atomic<long> atomic_long;


  typedef atomic<unsigned long> atomic_ulong;


  typedef atomic<long long> atomic_llong;


  typedef atomic<unsigned long long> atomic_ullong;


  typedef atomic<wchar_t> atomic_wchar_t;



  typedef atomic<char8_t> atomic_char8_t;



  typedef atomic<char16_t> atomic_char16_t;


  typedef atomic<char32_t> atomic_char32_t;






  typedef atomic<int8_t> atomic_int8_t;


  typedef atomic<uint8_t> atomic_uint8_t;


  typedef atomic<int16_t> atomic_int16_t;


  typedef atomic<uint16_t> atomic_uint16_t;


  typedef atomic<int32_t> atomic_int32_t;


  typedef atomic<uint32_t> atomic_uint32_t;


  typedef atomic<int64_t> atomic_int64_t;


  typedef atomic<uint64_t> atomic_uint64_t;



  typedef atomic<int_least8_t> atomic_int_least8_t;


  typedef atomic<uint_least8_t> atomic_uint_least8_t;


  typedef atomic<int_least16_t> atomic_int_least16_t;


  typedef atomic<uint_least16_t> atomic_uint_least16_t;


  typedef atomic<int_least32_t> atomic_int_least32_t;


  typedef atomic<uint_least32_t> atomic_uint_least32_t;


  typedef atomic<int_least64_t> atomic_int_least64_t;


  typedef atomic<uint_least64_t> atomic_uint_least64_t;



  typedef atomic<int_fast8_t> atomic_int_fast8_t;


  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;


  typedef atomic<int_fast16_t> atomic_int_fast16_t;


  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;


  typedef atomic<int_fast32_t> atomic_int_fast32_t;


  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;


  typedef atomic<int_fast64_t> atomic_int_fast64_t;


  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;



  typedef atomic<intptr_t> atomic_intptr_t;


  typedef atomic<uintptr_t> atomic_uintptr_t;


  typedef atomic<size_t> atomic_size_t;


  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;


  typedef atomic<intmax_t> atomic_intmax_t;


  typedef atomic<uintmax_t> atomic_uintmax_t;


  inline bool
  atomic_flag_test_and_set_explicit(atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }

  inline bool
  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }


  inline bool
  atomic_flag_test(const atomic_flag* __a) noexcept
  { return __a->test(); }

  inline bool
  atomic_flag_test(const volatile atomic_flag* __a) noexcept
  { return __a->test(); }

  inline bool
  atomic_flag_test_explicit(const atomic_flag* __a,
       memory_order __m) noexcept
  { return __a->test(__m); }

  inline bool
  atomic_flag_test_explicit(const volatile atomic_flag* __a,
       memory_order __m) noexcept
  { return __a->test(__m); }


  inline void
  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
  { __a->clear(__m); }

  inline void
  atomic_flag_clear_explicit(volatile atomic_flag* __a,
        memory_order __m) noexcept
  { __a->clear(__m); }

  inline bool
  atomic_flag_test_and_set(atomic_flag* __a) noexcept
  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

  inline bool
  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

  inline void
  atomic_flag_clear(atomic_flag* __a) noexcept
  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }

  inline void
  atomic_flag_clear(volatile atomic_flag* __a) noexcept
  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }


  inline void
  atomic_flag_wait(atomic_flag* __a, bool __old) noexcept
  { __a->wait(__old); }

  inline void
  atomic_flag_wait_explicit(atomic_flag* __a, bool __old,
                                memory_order __m) noexcept
  { __a->wait(__old, __m); }

  inline void
  atomic_flag_notify_one(atomic_flag* __a) noexcept
  { __a->notify_one(); }

  inline void
  atomic_flag_notify_all(atomic_flag* __a) noexcept
  { __a->notify_all(); }





  template<typename _Tp>
    using __atomic_val_t = __type_identity_t<_Tp>;
  template<typename _Tp>
    using __atomic_diff_t = typename atomic<_Tp>::difference_type;




  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline void
    atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const volatile atomic<_ITp>* __a,
    memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(volatile atomic<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }


  template<typename _ITp>
    inline void
    atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline void
    atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const volatile atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(volatile atomic<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }



  template<typename _Tp>
    inline void
    atomic_wait(const atomic<_Tp>* __a,
         typename std::atomic<_Tp>::value_type __old) noexcept
    { __a->wait(__old); }

  template<typename _Tp>
    inline void
    atomic_wait_explicit(const atomic<_Tp>* __a,
    typename std::atomic<_Tp>::value_type __old,
    std::memory_order __m) noexcept
    { __a->wait(__old, __m); }

  template<typename _Tp>
    inline void
    atomic_notify_one(atomic<_Tp>* __a) noexcept
    { __a->notify_one(); }

  template<typename _Tp>
    inline void
    atomic_notify_all(atomic<_Tp>* __a) noexcept
    { __a->notify_all(); }






  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(__atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }


  template<>
    struct atomic<float> : __atomic_float<float>
    {
      atomic() noexcept = default;

      constexpr
      atomic(float __fp) noexcept : __atomic_float<float>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<float>::operator=;
    };

  template<>
    struct atomic<double> : __atomic_float<double>
    {
      atomic() noexcept = default;

      constexpr
      atomic(double __fp) noexcept : __atomic_float<double>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<double>::operator=;
    };

  template<>
    struct atomic<long double> : __atomic_float<long double>
    {
      atomic() noexcept = default;

      constexpr
      atomic(long double __fp) noexcept : __atomic_float<long double>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<long double>::operator=;
    };
# 1761 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 3
  template<typename _Tp>
    struct atomic_ref : __atomic_ref<_Tp>
    {
      explicit
      atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
      { }

      atomic_ref& operator=(const atomic_ref&) = delete;

      atomic_ref(const atomic_ref&) = default;

      using __atomic_ref<_Tp>::operator=;
    };




  using atomic_signed_lock_free
    = atomic<make_signed_t<__detail::__platform_wait_t>>;
  using atomic_unsigned_lock_free
    = atomic<make_unsigned_t<__detail::__platform_wait_t>>;
# 1799 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/atomic" 3
}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 3
class TClass;
class TBuffer;
class TDirectory;
class TMemberInspector;
class TObject;
class TNamed;
class TCollection;
class TFileMergeInfo;
class TString;


enum ESysConstants {
   kMAXSIGNALS = 16,
   kMAXPATHLEN = 8192,
   kBUFFERSIZE = 8192,
   kItimerResolution = 10
};

enum EColor { kWhite =0, kBlack =1, kGray =920,
              kRed =632, kGreen =416, kBlue =600, kYellow =400, kMagenta =616, kCyan =432,
              kOrange =800, kSpring =820, kTeal =840, kAzure =860, kViolet =880, kPink =900,
              kGrape =100, kBrown =101, kAsh =102,
              kP6Blue =103, kP6Yellow =104, kP6Red =105, kP6Grape=106, kP6Gray =107, kP6Violet=108,
              kP8Blue =109, kP8Orange =110, kP8Red =111, kP8Pink =112, kP8Green =113, kP8Cyan =114, kP8Azure =115, kP8Gray =116,
              kP10Blue =117, kP10Yellow=118, kP10Red =119, kP10Gray=120, kP10Violet=121, kP10Brown=122, kP10Orange=123, kP10Green=124, kP10Ash=125, kP10Cyan=126
            };


class TClassStreamer;
class TMemberStreamer;
typedef void (*ClassStreamerFunc_t)(TBuffer&, void*);
typedef void (*ClassConvStreamerFunc_t)(TBuffer&, void*, const TClass*);
typedef void (*MemberStreamerFunc_t)(TBuffer&, void*, Int_t);


class TVirtualCollectionProxy;

typedef void (*VoidFuncPtr_t)();
typedef TClass* (*DictFuncPtr_t)();
# 99 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 3
typedef void (*ShowMembersFunc_t)(const void *obj, TMemberInspector &R__insp, Bool_t isTransient);
class TVirtualIsAProxy;
typedef TClass *(*IsAGlobalFunc_t)(const TClass*, const void *obj);


template <class Tmpl> TBuffer &operator>>(TBuffer &buf, Tmpl *&obj);
template <class Tmpl> TBuffer &operator<<(TBuffer &buf, const Tmpl *obj);




namespace ROOT {

   class TGenericClassInfo;
   class TClassAlt;
   typedef void *(*NewFunc_t)(void *);
   typedef void *(*NewArrFunc_t)(Long_t size, void *arena);
   typedef void (*DelFunc_t)(void *);
   typedef void (*DelArrFunc_t)(void *);
   typedef void (*DesFunc_t)(void *);
   typedef void (*DirAutoAdd_t)(void *, TDirectory *);
   typedef Long64_t (*MergeFunc_t)(void *, TCollection *, TFileMergeInfo *);
   typedef void (*ResetAfterMergeFunc_t)(void *, TFileMergeInfo *);

   template <class RootClass> Short_t SetClassVersion(RootClass *);

   extern TClass *CreateClass(const char *cname, Version_t id,
                              const std::type_info &info, TVirtualIsAProxy *isa,
                              const char *dfil, const char *ifil,
                              Int_t dl, Int_t il);
   extern void AddClass(const char *cname, Version_t id, const std::type_info &info,
                        DictFuncPtr_t dict, Int_t pragmabits);
   extern void RemoveClass(const char *cname, TClass *cl);
   extern void ResetClassVersion(TClass*, const char*, Short_t);
   extern ROOT::TClassAlt* AddClassAlternate(const char *normName, const char *alternate);
   extern void RemoveClassAlternate(ROOT::TClassAlt*);

   extern TNamed *RegisterClassTemplate(const char *name,
                                        const char *file, Int_t line);

   extern void Class_ShowMembers(TClass *cl, const void *obj, TMemberInspector&);
# 151 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 3
   namespace Internal {
   class TInitBehavior {




   public:
      virtual ~TInitBehavior() { }

      virtual void Register(const char *cname, Version_t id,
                            const std::type_info &info,
                            DictFuncPtr_t dict, Int_t pragmabits) const = 0;
      virtual void Unregister(const char *classname, TClass *cl) const = 0;
      virtual TClass *CreateClass(const char *cname, Version_t id,
                                  const std::type_info &info, TVirtualIsAProxy *isa,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const = 0;
   };

   class TDefaultInitBehavior: public TInitBehavior {
   public:
      void Register(const char *cname, Version_t id,
                            const std::type_info &info,
                            DictFuncPtr_t dict, Int_t pragmabits) const override {
         ROOT::AddClass(cname, id, info, dict, pragmabits);
      }

      void Unregister(const char *classname, TClass *cl) const override {
         ROOT::RemoveClass(classname, cl);
      }

      TClass *CreateClass(const char *cname, Version_t id,
                                  const std::type_info &info, TVirtualIsAProxy *isa,
                                  const char *dfil, const char *ifil,
                                  Int_t dl, Int_t il) const override {
         return ROOT::CreateClass(cname, id, info, isa, dfil, ifil, dl, il);
      }
   };

   const TInitBehavior *DefineBehavior(void * ,
                                       void * );
   }

}



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TGenericClassInfo.h" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TGenericClassInfo.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSchemaHelper.h" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSchemaHelper.h" 3
namespace ROOT {
namespace Internal {
   struct TSchemaHelper
   {
      TSchemaHelper(): fTarget(), fSourceClass(),
       fSource(), fCode(), fVersion(), fChecksum(),
       fInclude(), fEmbed(true), fFunctionPtr(nullptr),
       fAttributes() {}
      std::string fTarget;
      std::string fSourceClass;
      std::string fSource;
      std::string fCode;
      std::string fVersion;
      std::string fChecksum;
      std::string fInclude;
      Bool_t fEmbed;
      void* fFunctionPtr;
      std::string fAttributes;

      TSchemaHelper(const TSchemaHelper &tsh) :
       fTarget(tsh.fTarget), fSourceClass(tsh.fSourceClass),
       fSource(tsh.fSource), fCode(tsh.fCode), fVersion(tsh.fVersion),fChecksum(tsh.fChecksum),
       fInclude(tsh.fInclude), fEmbed(tsh.fEmbed), fFunctionPtr(tsh.fFunctionPtr),
       fAttributes(tsh.fAttributes) {}

      TSchemaHelper& operator=(const TSchemaHelper &) {return *this;}
   };
}
}
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TGenericClassInfo.h" 2 3




class TVirtualIsAProxy;


namespace ROOT {

   namespace Internal {

      std::string GetDemangledTypeName(const std::type_info&);
   }

   namespace Detail {
      class TCollectionProxyInfo;
   }

   class TGenericClassInfo {




      const Internal::TInitBehavior *fAction;
      TClass *fClass;
      const char *fClassName;
      const char *fDeclFileName;
      Int_t fDeclFileLine;
      DictFuncPtr_t fDictionary;
      const std::type_info &fInfo;
      const char *fImplFileName;
      Int_t fImplFileLine;
      TVirtualIsAProxy *fIsA;
      Int_t fVersion;
      MergeFunc_t fMerge;
      ResetAfterMergeFunc_t fResetAfterMerge;
      NewFunc_t fNew;
      NewArrFunc_t fNewArray;
      DelFunc_t fDelete;
      DelArrFunc_t fDeleteArray;
      DesFunc_t fDestructor;
      DirAutoAdd_t fDirAutoAdd;
      TClassStreamer *fStreamer;
      ClassStreamerFunc_t fStreamerFunc;
      ClassConvStreamerFunc_t fConvStreamerFunc;
      TVirtualCollectionProxy *fCollectionProxy;
      Int_t fSizeof;
      Int_t fPragmaBits;
      Detail::TCollectionProxyInfo *fCollectionProxyInfo;
      Detail::TCollectionProxyInfo *fCollectionStreamerInfo;
      std::vector<ROOT::Internal::TSchemaHelper> fReadRules;
      std::vector<ROOT::Internal::TSchemaHelper> fReadRawRules;
      std::vector<ROOT::TClassAlt*> fAlternate;

   public:
      TGenericClassInfo(const char *fullClassname,
                       const char *declFileName, Int_t declFileLine,
                       const std::type_info &info, const Internal::TInitBehavior *action,
                       DictFuncPtr_t dictionary,
                       TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof);

      TGenericClassInfo(const char *fullClassname, Int_t version,
                       const char *declFileName, Int_t declFileLine,
                       const std::type_info &info, const Internal::TInitBehavior *action,
                       DictFuncPtr_t dictionary,
                       TVirtualIsAProxy *isa, Int_t pragmabits, Int_t sizof);

      TGenericClassInfo(const char *fullClassname, Int_t version,
                        const char *declFileName, Int_t declFileLine,
                        const Internal::TInitBehavior *action,
                        DictFuncPtr_t dictionary, Int_t pragmabits);

      void Init(Int_t pragmabits);
      ~TGenericClassInfo();

      const Internal::TInitBehavior &GetAction() const;
      TClass *GetClass();
      const char *GetClassName() const;
      Detail::TCollectionProxyInfo *GetCollectionProxyInfo() const;
      Detail::TCollectionProxyInfo *GetCollectionStreamerInfo() const;
      const char *GetDeclFileName() const;
      Int_t GetDeclFileLine() const;
      DelFunc_t GetDelete() const;
      DelArrFunc_t GetDeleteArray() const;
      DesFunc_t GetDestructor() const;
      DirAutoAdd_t GetDirectoryAutoAdd() const;
      const char *GetImplFileName();
      Int_t GetImplFileLine();
      const std::type_info &GetInfo() const;
      TVirtualIsAProxy *GetIsA() const;
      NewFunc_t GetNew() const;
      NewArrFunc_t GetNewArray() const;
      const std::vector<ROOT::Internal::TSchemaHelper> &GetReadRawRules() const;
      const std::vector<ROOT::Internal::TSchemaHelper> &GetReadRules() const;
      Int_t GetVersion() const;

      TClass *IsA(const void *obj);

      void AdoptAlternate(ROOT::TClassAlt *alt);
      Short_t AdoptStreamer(TClassStreamer*);
      Short_t AdoptCollectionProxy(TVirtualCollectionProxy*);
      void AdoptCollectionProxyInfo(Detail::TCollectionProxyInfo*);
      void AdoptCollectionStreamerInfo(Detail::TCollectionProxyInfo*);
      Int_t SetDeclFile(const char *file, Int_t line);
      void SetDelete(DelFunc_t deleteFunc);
      void SetDeleteArray(DelArrFunc_t deleteArrayFunc);
      void SetDestructor(DesFunc_t destructorFunc);
      void SetDirectoryAutoAdd(DirAutoAdd_t dirAutoAdd);
      void SetFromTemplate();
      Int_t SetImplFile(const char *file, Int_t line);
      void SetMerge(MergeFunc_t);
      void SetResetAfterMerge(ResetAfterMergeFunc_t);
      void SetNew(NewFunc_t newFunc);
      void SetNewArray(NewArrFunc_t newArrayFunc);
      void SetReadRawRules( const std::vector<ROOT::Internal::TSchemaHelper>& rules );
      void SetReadRules( const std::vector<ROOT::Internal::TSchemaHelper>& rules );
      Short_t SetStreamer(ClassStreamerFunc_t);
      void SetStreamerFunc(ClassStreamerFunc_t);
      void SetConvStreamerFunc(ClassConvStreamerFunc_t);
      Short_t SetVersion(Short_t version);


   private:
      void CreateRuleSet( std::vector<ROOT::Internal::TSchemaHelper>& vect, Bool_t ProcessReadRules );
      TGenericClassInfo(const TGenericClassInfo &) = delete;
      TGenericClassInfo& operator=(const TGenericClassInfo &) = delete;

   private:
      TGenericClassInfo();

   };

}
# 199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3

typedef std::atomic<TClass*> atomic_TClass_ptr;

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIsAProxy.h" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIsAProxy.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualIsAProxy.h" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualIsAProxy.h" 3
class TClass;
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualIsAProxy.h" 3
class TClass;

class TVirtualIsAProxy {
public:
   virtual ~TVirtualIsAProxy() { }
   virtual void SetClass(TClass *cl) = 0;
   virtual TClass* operator()(const void *obj) = 0;
};
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIsAProxy.h" 2 3




class TClass;






class TIsAProxy : public TVirtualIsAProxy {
private:
   template <typename T> using Atomic_t = std::atomic<T>;






   static constexpr UInt_t fgMaxLastSlot = 8;

   const std::type_info *fType;
   TClass *fClass;
   Atomic_t<void*> fLasts[fgMaxLastSlot];
   Char_t fSubTypes[72];
   mutable Atomic_t<UInt_t> fSubTypesReaders;
   Atomic_t<Bool_t> fSubTypesWriteLockTaken;
   Atomic_t<UChar_t> fNextLastSlot;
   Atomic_t<Bool_t> fInit;
   Bool_t fVirtual;

   void* FindSubType(const std::type_info*) const;
   void* CacheSubType(const std::type_info*, TClass*);
protected:
   TIsAProxy(const TIsAProxy&) = delete;
   TIsAProxy& operator=(const TIsAProxy&) = delete;

public:

   TIsAProxy(const std::type_info &typ);

   virtual ~TIsAProxy();

   void SetClass(TClass *cl) override;

   TClass* operator()(const void *obj) override;
};






template <class T> class TInstrumentedIsAProxy : public TVirtualIsAProxy {

private:
   TClass *fClass;

protected:
   TInstrumentedIsAProxy(const TInstrumentedIsAProxy& iip) :
     TVirtualIsAProxy(iip), fClass(iip.fClass) { }
   TInstrumentedIsAProxy& operator=(const TInstrumentedIsAProxy& iip)
     {if(this!=&iip) {TVirtualIsAProxy::operator=(iip); fClass=iip.fClass;}
     return *this;}

public:

   TInstrumentedIsAProxy(TClass *cl) : fClass(cl) {}

   virtual ~TInstrumentedIsAProxy() {}

   virtual void SetClass(TClass *cl) override { fClass = cl; }

   TClass* operator()(const void *obj) override {
      return !obj ? fClass : ((const T*)obj)->IsA();
   }
};
# 203 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Rtypes.h" 2 3


namespace ROOT { namespace Internal {

class TCDGIILIBase {
public:

   static void SetInstance(::ROOT::TGenericClassInfo& R__instance,
                    NewFunc_t, NewArrFunc_t, DelFunc_t, DelArrFunc_t, DesFunc_t);
   static void SetName(const std::string& name, std::string& nameMember);
   static void SetfgIsA(atomic_TClass_ptr& isA, TClass*(*dictfun)());
};

template <typename T>
class ClassDefGenerateInitInstanceLocalInjector:
   public TCDGIILIBase {
      static atomic_TClass_ptr fgIsA;
      static ::ROOT::TGenericClassInfo *fgGenericInfo;
   public:
      static void *New(void *p) { return p ? new(p) T : new T; };
      static void *NewArray(Long_t nElements, void *p) {
         return p ? new(p) T[nElements] : new T[nElements]; }
      static void Delete(void *p) { delete ((T*)p); }
      static void DeleteArray(void *p) { delete[] ((T*)p); }
      static void Destruct(void *p) { ((T*)p)->~T(); }
      static ::ROOT::TGenericClassInfo *GenerateInitInstanceLocal() {
         static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy<T>(nullptr);
         static ::ROOT::TGenericClassInfo
            R__instance(T::Class_Name(), T::Class_Version(),
                        T::DeclFileName(), T::DeclFileLine(),
                        typeid(T), ::ROOT::Internal::DefineBehavior((T*)nullptr, (T*)nullptr),
                        &T::Dictionary, isa_proxy, 0, sizeof(T) );
         SetInstance(R__instance, &New, &NewArray, &Delete, &DeleteArray, &Destruct);
         return &R__instance;
      }




      static TClass *Dictionary() { fgIsA = fgGenericInfo->GetClass(); return fgIsA; }
      static TClass *Class() { SetfgIsA(fgIsA, &Dictionary); return fgIsA; }
      static const char* Name() {
         static std::string gName;
         if (gName.empty())
            SetName(GetDemangledTypeName(typeid(T)), gName);
         return gName.c_str();
      }
   };

   template<typename T>
   atomic_TClass_ptr ClassDefGenerateInitInstanceLocalInjector<T>::fgIsA{};
   template<typename T>
   ::ROOT::TGenericClassInfo *ClassDefGenerateInitInstanceLocalInjector<T>::fgGenericInfo {
      ClassDefGenerateInitInstanceLocalInjector<T>::GenerateInitInstanceLocal()
   };

   template <typename T>
   struct THashConsistencyHolder {
      static Bool_t fgHashConsistency;
   };

   template <typename T>
   Bool_t THashConsistencyHolder<T>::fgHashConsistency;

   void DefaultStreamer(TBuffer &R__b, const TClass *cl, void *objpointer);
   Bool_t HasConsistentHashMember(TClass &clRef);
   Bool_t HasConsistentHashMember(const char *clName);
}}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TStorage.h" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TStorage.h" 3
typedef void (*FreeHookFun_t)(void*, void *addr, size_t);
typedef void *(*ReAllocFun_t)(void*, size_t);
typedef void *(*ReAllocCFun_t)(void*, size_t, size_t);
typedef char *(*ReAllocCharFun_t)(char*, size_t, size_t);


class TStorage {

private:
   static size_t fgMaxBlockSize;
   static FreeHookFun_t fgFreeHook;
   static void *fgFreeHookData;
   static ReAllocCFun_t fgReAllocCHook;
   static Bool_t fgHasCustomNewDelete;


   enum {
      kIsOnHeap = 0x01000000,
   };

public:
   static const UInt_t kObjectAllocMemValue = 0x99999999;


public:
   virtual ~TStorage() { }

   static FreeHookFun_t GetFreeHook();
   static void *GetFreeHookData();
   static size_t GetMaxBlockSize();
   static void *Alloc(size_t size);
   static void Dealloc(void *ptr);
   static void *ReAlloc(void *vp, size_t size, size_t oldsize);
   static char *ReAllocChar(char *vp, size_t size, size_t oldsize);
   static Int_t *ReAllocInt(Int_t *vp, size_t size, size_t oldsize);
   static void *ObjectAlloc(size_t size);
   static void *ObjectAllocArray(size_t size);
   static void *ObjectAlloc(size_t size, void *vp);
   static void ObjectDealloc(void *vp);

   static void ObjectDealloc(void *vp, size_t size);

   static void ObjectDealloc(void *vp, void *ptr);

   static void EnterStat(size_t size, void *p);
   static void RemoveStat(void *p);
   static void PrintStatistics();
   static void SetMaxBlockSize(size_t size);
   static void SetFreeHook(FreeHookFun_t func, void *data);
   static void SetReAllocHooks(ReAllocFun_t func1, ReAllocCFun_t func2);
   static void SetCustomNewDelete();
   static void EnableStatistics(int size= -1, int ix= -1);

   static Bool_t HasCustomNewDelete();

   static Bool_t FilledByObjectAlloc(volatile const UInt_t* const member);
   static void UpdateIsOnHeap(volatile const UInt_t &uniqueID, volatile UInt_t &bits);

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TStorage") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } virtual TClass *IsA() const { return TStorage::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TStorage::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TStorage::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TStorage.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 85; }
};

inline Bool_t TStorage::FilledByObjectAlloc(volatile const UInt_t *const member) {
# 111 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TStorage.h" 3
   return *member == kObjectAllocMemValue;

}
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TStorage.h" 3
inline __attribute__((noinline)) void TStorage::UpdateIsOnHeap(volatile const UInt_t &uniqueID, volatile UInt_t &bits) {
   if (TStorage::FilledByObjectAlloc(&uniqueID))
      bits = bits | kIsOnHeap;
   else
      bits = bits & ~kIsOnHeap;
}


inline size_t TStorage::GetMaxBlockSize() { return fgMaxBlockSize; }

inline void TStorage::SetMaxBlockSize(size_t size) { fgMaxBlockSize = size; }

inline FreeHookFun_t TStorage::GetFreeHook() { return fgFreeHook; }

namespace ROOT {
namespace Internal {
using FreeIfTMapFile_t = bool(void*);
using GetMapFileMapllocDesc_t = void *(void*);
 extern FreeIfTMapFile_t *gFreeIfTMapFile;
 extern GetMapFileMapllocDesc_t *gGetMapFileMallocDesc;
 extern void *gMmallocDesc;
}
}
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVersionCheck.h" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVersionCheck.h" 3
class TVersionCheck {
public:
   TVersionCheck(int versionCode);
};

namespace ROOT {
namespace Internal {
static TVersionCheck gVersionCheck((((6) << 16) + ((36) << 8) + (6)));
}
}
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg_header_macro.h" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg_va_list.h" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg_va_list.h" 3
typedef __builtin_va_list va_list;
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg_va_arg.h" 1 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg___va_copy.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stdarg_va_copy.h" 1 3
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 2 3







class TList;
class TBrowser;
class TBuffer;
class TObjArray;
class TMethod;
class TTimer;

namespace ROOT {
namespace Internal {
   bool DeleteChangesMemoryImpl();
}}

class TObject {

private:
   UInt_t fUniqueID;
   UInt_t fBits;

   static Longptr_t fgDtorOnly;
   static Bool_t fgObjectStat;

   static void AddToTObjectTable(TObject *);

protected:
   void MakeZombie() { fBits |= kZombie; }
   virtual void DoError(int level, const char *location, const char *fmt, va_list va) const;

   static void SavePrimitiveConstructor(std::ostream &out, TClass *cl, const char *variable_name, const char *constructor_agrs = "", Bool_t empty_line = kTRUE);

   static TString SavePrimitiveVector(std::ostream &out, const char *prefix, Int_t len, Double_t *arr, Bool_t empty_line = kFALSE);

   static void SavePrimitiveDraw(std::ostream &out, const char *variable_name, Option_t *option = nullptr);

public:




   enum EStatusBits {
      kCanDelete = (1ULL << (0)),

      kMustCleanup = (1ULL << (3)),
      kIsReferenced = (1ULL << (4)),
      kHasUUID = (1ULL << (5)),
      kCannotPick = (1ULL << (6)),

      kNoContextMenu = (1ULL << (8)),


      kInvalidObject = (1ULL << (13))
   };

   enum EDeprecatedStatusBits {
      kObjInCanvas = (1ULL << (3))
   };


   enum {
      kIsOnHeap = 0x01000000,
      kNotDeleted = 0x02000000,
      kZombie = 0x04000000,
      kInconsistent = 0x08000000,

      kBitMask = 0x00ffffff
   };


   enum {
      kSingleKey = (1ULL << (0)),
      kOverwrite = (1ULL << (1)),
      kWriteDelete = (1ULL << (2)),
   };

protected:
   enum {
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
      kOnlyPrepStep = (1ULL << (3))
   };

public:

   TObject();
   TObject(const TObject &object);
   TObject &operator=(const TObject &rhs);
   virtual ~TObject();

   virtual void AppendPad(Option_t *option="");
   virtual void Browse(TBrowser *b);
   virtual const char *ClassName() const;
   virtual void Clear(Option_t * ="") { }
           ULong_t CheckedHash();
   virtual TObject *Clone(const char *newname="") const;
   virtual Int_t Compare(const TObject *obj) const;
   virtual void Copy(TObject &object) const;
   virtual void Delete(Option_t *option="");
   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
   virtual void Draw(Option_t *option="");
   virtual void DrawClass() const;
   virtual TObject *DrawClone(Option_t *option="") const;
   virtual void Dump() const;
   virtual void Execute(const char *method, const char *params, Int_t *error = nullptr);
   virtual void Execute(TMethod *method, TObjArray *params, Int_t *error = nullptr);
   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
   virtual TObject *FindObject(const char *name) const;
   virtual TObject *FindObject(const TObject *obj) const;
   virtual Option_t *GetDrawOption() const;
   virtual UInt_t GetUniqueID() const;
   virtual const char *GetName() const;
   virtual const char *GetIconName() const;
   virtual Option_t *GetOption() const { return ""; }
   virtual char *GetObjectInfo(Int_t px, Int_t py) const;
   virtual const char *GetTitle() const;
   virtual Bool_t HandleTimer(TTimer *timer);
           Bool_t HasInconsistentHash() const;
   virtual ULong_t Hash() const;
   virtual Bool_t InheritsFrom(const char *classname) const;
   virtual Bool_t InheritsFrom(const TClass *cl) const;
   virtual void Inspect() const;
   virtual Bool_t IsFolder() const;
   virtual Bool_t IsEqual(const TObject *obj) const;
   virtual Bool_t IsSortable() const { return kFALSE; }

   inline __attribute__((always_inline)) Bool_t IsOnHeap() const { return TestBit(kIsOnHeap); }
   inline __attribute__((always_inline)) Bool_t IsZombie() const { return TestBit(kZombie); }

   virtual Bool_t Notify();
   virtual void ls(Option_t *option="") const;
   virtual void Paint(Option_t *option="");
   virtual void Pop();
   virtual void Print(Option_t *option="") const;
   virtual Int_t Read(const char *name);
   virtual void RecursiveRemove(TObject *obj);
   virtual void SaveAs(const char *filename="",Option_t *option="") const;
   virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
   virtual void SetDrawOption(Option_t *option="");
   virtual void SetUniqueID(UInt_t uid);
   virtual void UseCurrentStyle();
   virtual Int_t Write(const char *name = nullptr, Int_t option = 0, Int_t bufsize = 0);
   virtual Int_t Write(const char *name = nullptr, Int_t option = 0, Int_t bufsize = 0) const;
# 184 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
   Bool_t IsDestructed() const { return !TestBit(kNotDeleted); }


   void *operator new(size_t sz) { return TStorage::ObjectAlloc(sz); }
   void *operator new[](size_t sz) { return TStorage::ObjectAllocArray(sz); }
   void *operator new(size_t sz, void *vp) { return TStorage::ObjectAlloc(sz, vp); }
   void *operator new[](size_t sz, void *vp) { return TStorage::ObjectAlloc(sz, vp); }
   void operator delete(void *ptr);
   void operator delete[](void *ptr);


   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);

   void operator delete(void *ptr, void *vp);
   void operator delete[](void *ptr, void *vp);


   void SetBit(UInt_t f, Bool_t set);
   void SetBit(UInt_t f) { fBits |= f & kBitMask; }
   void ResetBit(UInt_t f) { fBits &= ~(f & kBitMask); }
   inline __attribute__((always_inline)) Bool_t TestBit(UInt_t f) const { return (Bool_t) ((fBits & f) != 0); }
   Int_t TestBits(UInt_t f) const { return (Int_t) (fBits & f); }
   void InvertBit(UInt_t f) { fBits ^= f & kBitMask; }


   virtual void Info(const char *method, const char *msgfmt, ...) const

   __attribute__((format(printf, 3, 4)))

   ;
   virtual void Warning(const char *method, const char *msgfmt, ...) const

   __attribute__((format(printf, 3, 4)))

   ;
   virtual void Error(const char *method, const char *msgfmt, ...) const

   __attribute__((format(printf, 3, 4)))

   ;
   virtual void SysError(const char *method, const char *msgfmt, ...) const

   __attribute__((format(printf, 3, 4)))

   ;
   virtual void Fatal(const char *method, const char *msgfmt, ...) const

   __attribute__((format(printf, 3, 4)))

   ;

   void AbstractMethod(const char *method) const;
   void MayNotUse(const char *method) const;
   void Obsolete(const char *method, const char *asOfVers, const char *removedFromVers) const;


   static Longptr_t GetDtorOnly();
   static void SetDtorOnly(void *obj);
   static Bool_t GetObjectStat();
   static void SetObjectStat(Bool_t stat);

   friend class TClonesArray;
   friend bool ROOT::Internal::DeleteChangesMemoryImpl();

   private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TObject") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return TObject::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TObject::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TObject::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 249; }
};
# 260 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
inline TObject::TObject() : fBits(kNotDeleted)
{


   TStorage::UpdateIsOnHeap(fUniqueID, fBits);

   fUniqueID = 0;




   if (__builtin_expect(!!(fgObjectStat), 0)) TObject::AddToTObjectTable(this);

}




inline TObject::TObject(const TObject &obj)
{
   fBits = obj.fBits;



   TStorage::UpdateIsOnHeap(fUniqueID, fBits);

   fBits &= ~kIsReferenced;
   fBits &= ~kCanDelete;


   fUniqueID = obj.fUniqueID;




   if (__builtin_expect(!!(fgObjectStat), 0)) TObject::AddToTObjectTable(this);

}




inline TObject &TObject::operator=(const TObject &rhs)
{
   if (__builtin_expect(!!(this != &rhs), 1)) {
      fUniqueID = rhs.fUniqueID;
      if (IsOnHeap()) {
         fBits = rhs.fBits;
         fBits |= kIsOnHeap;
      } else {
         fBits = rhs.fBits;
         fBits &= ~kIsOnHeap;
      }
      fBits &= ~kIsReferenced;
      fBits &= ~kCanDelete;
   }
   return *this;
}
# 330 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
inline ULong_t TObject::CheckedHash()
{
# 345 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
   if (!CheckTObjectHashConsistency())
      fBits |= kInconsistent;


   return Hash();
}
# 364 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
inline Bool_t TObject::HasInconsistentHash() const
{
   return fBits & kInconsistent;
}




enum EObjBits {
   kCanDelete = TObject::kCanDelete,
   kMustCleanup = TObject::kMustCleanup,
   kObjInCanvas = TObject::kObjInCanvas,
   kIsReferenced = TObject::kIsReferenced,
   kHasUUID = TObject::kHasUUID,
   kCannotPick = TObject::kCannotPick,
   kNoContextMenu = TObject::kNoContextMenu,
   kInvalidObject = TObject::kInvalidObject
};

namespace cling {
   std::string printValue(TObject *val);
}

namespace ROOT {

namespace Internal {
   bool DeleteChangesMemory();
}

namespace Detail {
# 408 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObject.h" 3
inline __attribute__((always_inline)) bool HasBeenDeleted(const TObject *obj) {
   return !ROOT::Internal::DeleteChangesMemory() && obj->IsDestructed();
}

}}
# 16 "include/klm/dbobjects/bklm/BKLMGeometryPar.h" 2





static const int NSCINTLAYER = 2;
static const int NPHISCINT = 48;
static const int NZSCINT = 54;
static const int NSTATION = 7;
static const int BKLM_INNER = 1;
static const int BKLM_OUTER = 2;

namespace Belle2 {

  class GearDir;





  class BKLMGeometryPar: public TObject {

  public:


    BKLMGeometryPar()
    {
    }


    explicit BKLMGeometryPar(const GearDir&);


    ~BKLMGeometryPar();


    void read(const GearDir&);


    bool doBeamBackgroundStudy(void) const
    {
      return m_DoBeamBackgroundStudy;
    }


    void doBeamBackgroundStudy(bool flag)
    {
      m_DoBeamBackgroundStudy = flag;
    }


    bool hasRPCs(int layer) const
    {
      return m_HasRPCs[layer - 1];
    }


    void hasRPCs(int layer, bool flag)
    {
      m_HasRPCs[layer] = flag;
    }


    double getScintTiO2ThicknessTop(void) const
    {
      return m_ScintTiO2ThicknessTop;
    }


    void setScintTiO2ThicknessTop(double x)
    {
      m_ScintTiO2ThicknessTop = x;
    }


    double getScintTiO2ThicknessSide(void) const
    {
      return m_ScintTiO2ThicknessSide;
    }


    void setScintTiO2ThicknessSide(double x)
    {
      m_ScintTiO2ThicknessSide = x;
    }


    double getChimneyLength(void) const
    {
      return m_ChimneyLength;
    }


    void setChimneyLength(double x)
    {
      m_ChimneyLength = x;
    }


    double getChimneyWidth(void) const
    {
      return m_ChimneyWidth;
    }


    void setChimneyWidth(double x)
    {
      m_ChimneyWidth = x;
    }


    double getScintHeight(void) const
    {
      return m_ScintHeight;
    }


    void setScintHeight(double x)
    {
      m_ScintHeight = x;
    }


    double getScintWidth(void) const
    {
      return m_ScintWidth;
    }


    void setScintWidth(double x)
    {
      m_ScintWidth = x;
    }


    double getScintBoreRadius(void) const
    {
      return m_ScintBoreRadius;
    }


    void setScintBoreRadius(double x)
    {
      m_ScintBoreRadius = x;
    }


    double getScintFiberRadius(void) const
    {
      return m_ScintFiberRadius;
    }


    void setScintFiberRadius(double x)
    {
      m_ScintFiberRadius = x;
    }


    double getRotation(void) const
    {
      return m_Rotation;
    }


    void setRotation(double x)
    {
      m_Rotation = x;
    }


    double getSectorRotation(int section, int sector) const
    {
      return m_SectorRotation[section][sector - 1];
    }


    void setSectorRotation(int section, int sector, double x)
    {
      m_SectorRotation[section][sector - 1] = x;
    }


    double getOffsetZ(void) const
    {
      return m_OffsetZ;
    }


    void setOffsetZ(double x)
    {
      m_OffsetZ = x;
    }


    double getPhi(void) const
    {
      return m_Phi;
    }


    void setPhi(double x)
    {
      m_Phi = x;
    }


    double getSolenoidOuterRadius(void) const
    {
      return m_SolenoidOuterRadius;
    }


    void setSolenoidOuterRadius(double x)
    {
      m_SolenoidOuterRadius = x;
    }


    int getNSector(void) const
    {
      return m_NSector;
    }


    void setNSector(int n)
    {
      m_NSector = n;
    }


    double getHalfLength(void) const
    {
      return m_HalfLength;
    }


    void setHalfLength(double x)
    {
      m_HalfLength = x;
    }


    double getOuterRadius(void) const
    {
      return m_OuterRadius;
    }


    void setOuterRadius(double x)
    {
      m_OuterRadius = x;
    }


    int getNLayer(void) const
    {
      return m_NLayer;
    }


    void setNLayer(double n)
    {
      m_NLayer = n;
    }


    double getIronNominalHeight(void) const
    {
      return m_IronNominalHeight;
    }


    void setIronNominalHeight(double x)
    {
      m_IronNominalHeight = x;
    }


    double getIronActualHeight(void) const
    {
      return m_IronActualHeight;
    }


    void setIronActualHeight(double x)
    {
      m_IronActualHeight = x;
    }


    double getGap1InnerRadius(void) const
    {
      return m_Gap1InnerRadius;
    }


    void setGap1InnerRadius(double x)
    {
      m_Gap1InnerRadius = x;
    }


    double getGap1NominalHeight(void) const
    {
      return m_Gap1NominalHeight;
    }


    void setGap1NominalHeight(double x)
    {
      m_Gap1NominalHeight = x;
    }


    double getGap1IronWidth(void) const
    {
      return m_Gap1IronWidth;
    }


    void setGap1IronWidth(double x)
    {
      m_Gap1IronWidth = x;
    }


    double getGapLength(void) const
    {
      return m_GapLength;
    }


    void setGapLength(double x)
    {
      m_GapLength = x;
    }


    double getGapNominalHeight(void) const
    {
      return m_GapNominalHeight;
    }


    void setGapNominalHeight(double x)
    {
      m_GapNominalHeight = x;
    }


    double getGapIronWidth(void) const
    {
      return m_GapIronWidth;
    }


    void setGapIronWidth(double x)
    {
      m_GapIronWidth = x;
    }


    int getNZStrips(void) const
    {
      return m_NZStrips;
    }


    void setNZStrips(int n)
    {
      m_NZStrips = n;
    }


    int getNZStripsChimney(void) const
    {
      return m_NZStripsChimney;
    }


    void setNZStripsChimney(int n)
    {
      m_NZStripsChimney = n;
    }


    int getNPhiStrips(int layer) const
    {
      return m_NPhiStrips[layer - 1];
    }


    void setNPhiStrips(int layer, int n)
    {
      m_NPhiStrips[layer - 1] = n;
    }


    int getNZScints(void) const
    {
      return m_NZScints;
    }


    void setNZScints(int n)
    {
      m_NZScints = n;
    }


    int getNZScintsChimney(void) const
    {
      return m_NZScintsChimney;
    }


    void setNZScintsChimney(int n)
    {
      m_NZScintsChimney = n;
    }


    int getNPhiScints(int layer) const
    {
      return m_NPhiScints[layer - 1];
    }


    void setNPhiScints(int layer, int n)
    {
      m_NPhiScints[layer - 1] = n;
    }



    double getScintEnvelopeOffsetSign(int layer) const
    {
      return m_ScintEnvelopeOffsetSign[layer - 1];
    }



    void setScintEnvelopeOffsetSign(int layer, int n)
    {
      m_ScintEnvelopeOffsetSign[layer - 1] = n;
    }


    double getPhiStripWidth(int layer) const
    {
      return m_PhiStripWidth[layer - 1];
    }


    void setPhiStripWidth(int layer, double x)
    {
      m_PhiStripWidth[layer - 1] = x;
    }


    double getZStripWidth(int layer) const
    {
      return m_ZStripWidth[layer - 1];
    }


    void setZStripWidth(int layer, double x)
    {
      m_ZStripWidth[layer - 1] = x;
    }



    double getZScintDLength(int layer, int scint) const
    {
      return m_ZScintDLength[layer - 1][scint - 1];
    }



    void setZScintDLength(int layer, int scint, double x)
    {
      m_ZScintDLength[layer - 1][scint - 1] = x;
    }


    double getModuleLength(void) const
    {
      return m_ModuleLength;
    }


    void setModuleLength(double x)
    {
      m_ModuleLength = x;
    }


    double getModuleLengthChimney(void) const
    {
      return m_ModuleLengthChimney;
    }


    void setModuleLengthChimney(double x)
    {
      m_ModuleLengthChimney = x;
    }


    double getModuleCoverHeight(void) const
    {
      return m_ModuleCoverHeight;
    }


    void setModuleCoverHeight(double x)
    {
      m_ModuleCoverHeight = x;
    }


    double getModuleCopperHeight(void) const
    {
      return m_ModuleCopperHeight;
    }


    void setModuleCopperHeight(double x)
    {
      m_ModuleCopperHeight = x;
    }


    double getModuleFoamHeight(void) const
    {
      return m_ModuleFoamHeight;
    }


    void setModuleFoamHeight(double x)
    {
      m_ModuleFoamHeight = x;
    }


    double getModuleMylarHeight(void) const
    {
      return m_ModuleMylarHeight;
    }


    void setModuleMylarHeight(double x)
    {
      m_ModuleMylarHeight = x;
    }


    double getModuleGlassHeight(void) const
    {
      return m_ModuleGlassHeight;
    }


    void setModuleGlassHeight(double moduleGlassHeight)
    {
      m_ModuleGlassHeight = moduleGlassHeight;
    }


    double getModuleGasHeight(void) const
    {
      return m_ModuleGasHeight;
    }


    void setModuleGasHeight(double x)
    {
      m_ModuleGasHeight = x;
    }


    double getModuleFrameWidth(void) const
    {
      return m_ModuleFrameWidth;
    }


    void setModuleFrameWidth(double x)
    {
      m_ModuleFrameWidth = x;
    }


    double getModuleFrameThickness(void) const
    {
      return m_ModuleFrameThickness;
    }


    void setModuleFrameThickness(double x)
    {
      m_ModuleFrameThickness = x;
    }


    double getModuleGasSpacerWidth(void) const
    {
      return m_ModuleGasSpacerWidth;
    }


    void setModuleGasSpacerWidth(double x)
    {
      m_ModuleGasSpacerWidth = x;
    }


    double getModulePolystyreneInnerHeight(void) const
    {
      return m_ModulePolystyreneInnerHeight;
    }


    void setModulePolystyreneInnerHeight(double x)
    {
      m_ModulePolystyreneInnerHeight = x;
    }


    double getModulePolystyreneOuterHeight(void) const
    {
      return m_ModulePolystyreneOuterHeight;
    }


    void setModulePolystyreneOuterHeight(double x)
    {
      m_ModulePolystyreneOuterHeight = x;
    }


    double getChimneyCoverThickness(void) const
    {
      return m_ChimneyCoverThickness;
    }


    void setChimneyCoverThickness(double x)
    {
      m_ChimneyCoverThickness = x;
    }


    double getChimneyHousingInnerRadius(void) const
    {
      return m_ChimneyHousingInnerRadius;
    }


    void setChimneyHousingInnerRadius(double x)
    {
      m_ChimneyHousingInnerRadius = x;
    }


    double getChimneyHousingOuterRadius(void) const
    {
      return m_ChimneyHousingOuterRadius;
    }


    void setChimneyHousingOuterRadius(double x)
    {
      m_ChimneyHousingOuterRadius = x;
    }


    double getChimneyShieldInnerRadius(void) const
    {
      return m_ChimneyShieldInnerRadius;
    }


    void setChimneyShieldInnerRadius(double x)
    {
      m_ChimneyShieldInnerRadius = x;
    }


    double getChimneyShieldOuterRadius(void) const
    {
      return m_ChimneyShieldOuterRadius;
    }


    void setChimneyShieldOuterRadius(double x)
    {
      m_ChimneyShieldOuterRadius = x;
    }


    double getChimneyPipeInnerRadius(void) const
    {
      return m_ChimneyPipeInnerRadius;
    }


    void setChimneyPipeInnerRadius(double x)
    {
      m_ChimneyPipeInnerRadius = x;
    }


    double getChimneyPipeOuterRadius(void) const
    {
      return m_ChimneyPipeOuterRadius;
    }


    void setChimneyPipeOuterRadius(double x)
    {
      m_ChimneyPipeOuterRadius = x;
    }


    double getRibThickness(void) const
    {
      return m_RibThickness;
    }


    void setRibThickness(double x)
    {
      m_RibThickness = x;
    }


    double getCablesWidth(void) const
    {
      return m_CablesWidth;
    }


    void setCablesWidth(double x)
    {
      m_CablesWidth = x;
    }


    double getBraceWidth(void) const
    {
      return m_BraceWidth;
    }


    void setBraceWidth(double x)
    {
      m_BraceWidth = x;
    }


    double getBraceWidthChimney(void) const
    {
      return m_BraceWidthChimney;
    }


    void setBraceWidthChimney(double x)
    {
      m_BraceWidthChimney = x;
    }


    double getSupportPlateWidth(void) const
    {
      return m_SupportPlateWidth;
    }


    void setSupportPlateWidth(double x)
    {
      m_SupportPlateWidth = x;
    }


    double getSupportPlateHeight(void) const
    {
      return m_SupportPlateHeight;
    }


    void setSupportPlateHeight(double x)
    {
      m_SupportPlateHeight = x;
    }


    double getSupportPlateLength(void) const
    {
      return m_SupportPlateLength;
    }


    void setSupportPlateLength(double x)
    {
      m_SupportPlateLength = x;
    }


    double getSupportPlateLengthChimney(void) const
    {
      return m_SupportPlateLengthChimney;
    }


    void setSupportPlateLengthChimney(double x)
    {
      m_SupportPlateLengthChimney = x;
    }


    double getBracketWidth(void) const
    {
      return m_BracketWidth;
    }


    void setBracketWidth(double x)
    {
      m_BracketWidth = x;
    }


    double getBracketThickness(void) const
    {
      return m_BracketThickness;
    }


    void setBracketThickness(double x)
    {
      m_BracketThickness = x;
    }


    double getBracketLength(void) const
    {
      return m_BracketLength;
    }


    void setBracketLength(double x)
    {
      m_BracketLength = x;
    }


    double getBracketRibWidth(void) const
    {
      return m_BracketRibWidth;
    }


    void setBracketRibWidth(double x)
    {
      m_BracketRibWidth = x;
    }


    double getBracketRibThickness(void) const
    {
      return m_BracketRibThickness;
    }


    void setBracketRibThickness(double x)
    {
      m_BracketRibThickness = x;
    }


    double getBracketInset(void)const
    {
      return m_BracketInset;
    }


    void setBracketInset(double x)
    {
      m_BracketInset = x;
    }


    double getBracketInnerRadius(void) const
    {
      return m_BracketInnerRadius;
    }


    void setBracketInnerRadius(double x)
    {
      m_BracketInnerRadius = x;
    }


    double getBracketCutoutDphi(void) const
    {
      return m_BracketCutoutDphi;
    }


    void setBracketCutoutDphi(double x)
    {
      m_BracketCutoutDphi = x;
    }


    int getNReadoutStation(void) const
    {
      return m_NReadoutStation;
    }


    bool getReadoutStationIsPhi(int station) const
    {
      return m_ReadoutStationIsPhi[station - 1];
    }


    double getReadoutStationPosition(int station) const
    {
      return m_ReadoutStationPosition[station - 1];
    }


    double getReadoutContainerLength(void) const
    {
      return m_ReadoutContainerLength;
    }


    double getReadoutContainerWidth(void) const
    {
      return m_ReadoutContainerWidth;
    }


    double getReadoutContainerHeight(void) const
    {
      return m_ReadoutContainerHeight;
    }


    double getReadoutCarrierLength(void) const
    {
      return m_ReadoutCarrierLength;
    }


    double getReadoutCarrierWidth(void) const
    {
      return m_ReadoutCarrierWidth;
    }


    double getReadoutCarrierHeight(void) const
    {
      return m_ReadoutCarrierHeight;
    }


    double getReadoutPreamplifierLength(void) const
    {
      return m_ReadoutPreamplifierLength;
    }


    double getReadoutPreamplifierWidth(void) const
    {
      return m_ReadoutPreamplifierWidth;
    }


    double getReadoutPreamplifierHeight(void) const
    {
      return m_ReadoutPreamplifierHeight;
    }


    int getNReadoutPreamplifierPosition(void) const
    {
      return m_ReadoutPreamplifierPosition.size();
    }


    double getReadoutPreamplifierPosition(int preamp) const
    {
      return m_ReadoutPreamplifierPosition[preamp - 1];
    }


    double getReadoutConnectorsLength(void) const
    {
      return m_ReadoutConnectorsLength;
    }


    double getReadoutConnectorsWidth(void) const
    {
      return m_ReadoutConnectorsWidth;
    }


    double getReadoutConnectorsHeight(void) const
    {
      return m_ReadoutConnectorsHeight;
    }


    double getReadoutConnectorsPosition(void) const
    {
      return m_ReadoutConnectorsPosition;
    }


    double getMPPCHousingRadius(void) const
    {
      return m_MPPCHousingRadius;
    }


    double getMPPCHousingLength(void) const
    {
      return m_MPPCHousingLength;
    }


    double getMPPCLength(void) const
    {
      return m_MPPCLength;
    }


    double getMPPCWidth(void) const
    {
      return m_MPPCWidth;
    }


    double getMPPCHeight(void) const
    {
      return m_MPPCHeight;
    }


    double getLocalReconstructionShiftX(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftX[section][sector - 1][layer - 1];
    }


    void setLocalReconstructionShiftX(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = x;
    }


    double getLocalReconstructionShiftY(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftY[section][sector - 1][layer - 1];
    }


    void setLocalReconstructionShiftY(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = x;
    }


    double getLocalReconstructionShiftZ(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftZ[section][sector - 1][layer - 1];
    }


    void setLocalReconstructionShiftZ(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = x;
    }




    bool isFlipped(int section, int sector, int layer) const
    {
      return m_IsFlipped[section][sector - 1][layer - 1];
    }




    void isFlipped(int section, int sector, int layer, bool flag)
    {
      m_IsFlipped[section][sector - 1][layer - 1] = flag;
    }


    std::string getBKLMGeometryParComment() const
    {
      return m_comment;
    }


    void setBKLMGeometryParComment(const std::string& s)
    {
      m_comment = s;
    }

  private:


    bool m_DoBeamBackgroundStudy;


    double m_Rotation;


    double m_SectorRotation[2][BKLMElementNumbers::getMaximalSectorNumber()];


    double m_OffsetZ;


    double m_Phi;


    int m_NSector;


    double m_SolenoidOuterRadius;


    double m_OuterRadius;


    double m_HalfLength;


    int m_NLayer;


    double m_IronNominalHeight;


    double m_IronActualHeight;


    double m_Gap1NominalHeight;


    double m_GapNominalHeight;


    double m_Gap1InnerRadius;


    double m_Gap1IronWidth;


    double m_GapIronWidth;


    double m_GapLength;


    int m_NZStrips;


    int m_NZStripsChimney;


    int m_NZScints;


    int m_NZScintsChimney;


    bool m_HasRPCs[BKLMElementNumbers::getMaximalLayerNumber()];


    int m_NPhiStrips[BKLMElementNumbers::getMaximalLayerNumber()];


    double m_PhiStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];


    double m_ZStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];




    int m_ScintEnvelopeOffsetSign[NSCINTLAYER];



    int m_NPhiScints[NSCINTLAYER];



    double m_ZScintDLength[NSCINTLAYER][NZSCINT];


    double m_ModuleLength;


    double m_ModuleLengthChimney;


    double m_ModuleCoverHeight;


    double m_ModuleCopperHeight;


    double m_ModuleFoamHeight;


    double m_ModuleMylarHeight;


    double m_ModuleGlassHeight;


    double m_ModuleGasHeight;


    double m_ModuleFrameWidth;


    double m_ModuleFrameThickness;


    double m_ModuleGasSpacerWidth;


    double m_ModulePolystyreneInnerHeight;


    double m_ModulePolystyreneOuterHeight;


    double m_ScintWidth;


    double m_ScintHeight;


    double m_ScintBoreRadius;


    double m_ScintFiberRadius;


    double m_ScintTiO2ThicknessTop;


    double m_ScintTiO2ThicknessSide;


    double m_ChimneyLength;


    double m_ChimneyWidth;


    double m_ChimneyCoverThickness;


    double m_ChimneyHousingInnerRadius;


    double m_ChimneyHousingOuterRadius;


    double m_ChimneyShieldInnerRadius;


    double m_ChimneyShieldOuterRadius;


    double m_ChimneyPipeInnerRadius;


    double m_ChimneyPipeOuterRadius;


    double m_RibThickness;


    double m_CablesWidth;


    double m_BraceWidth;


    double m_BraceWidthChimney;


    double m_SupportPlateWidth;


    double m_SupportPlateHeight;


    double m_SupportPlateLength;


    double m_SupportPlateLengthChimney;


    double m_BracketWidth;


    double m_BracketThickness;


    double m_BracketLength;


    double m_BracketRibWidth;


    double m_BracketRibThickness;


    double m_BracketInnerRadius;


    double m_BracketInset;


    double m_BracketCutoutDphi;


    int m_NReadoutStation;


    bool m_ReadoutStationIsPhi[NSTATION];


    double m_ReadoutStationPosition[NSTATION];


    double m_ReadoutContainerLength;


    double m_ReadoutContainerWidth;


    double m_ReadoutContainerHeight;


    double m_ReadoutCarrierLength;


    double m_ReadoutCarrierWidth;


    double m_ReadoutCarrierHeight;


    double m_ReadoutPreamplifierLength;


    double m_ReadoutPreamplifierWidth;


    double m_ReadoutPreamplifierHeight;


    std::vector<double> m_ReadoutPreamplifierPosition;


    double m_ReadoutConnectorsLength;


    double m_ReadoutConnectorsWidth;


    double m_ReadoutConnectorsHeight;


    double m_ReadoutConnectorsPosition;


    double m_MPPCHousingRadius;


    double m_MPPCHousingLength;


    double m_MPPCLength;


    double m_MPPCWidth;


    double m_MPPCHeight;


    double m_LocalReconstructionShiftX[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


    double m_LocalReconstructionShiftY[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


    double m_LocalReconstructionShiftZ[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


    bool m_IsFlipped[2][BKLMElementNumbers::getMaximalSectorNumber()][NSCINTLAYER];


    std::string m_comment;


    private: static_assert(std::is_integral<decltype(6)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("BKLMGeometryPar") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 6; } virtual TClass *IsA() const { return BKLMGeometryPar::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(BKLMGeometryPar::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { BKLMGeometryPar::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/klm/dbobjects/bklm/BKLMGeometryPar.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 1443; };

  };
}
# 14 "include/klm/bklm/geometry/GeometryPar.h" 2





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 1 3
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/aligned_buffer.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/aligned_buffer.h" 3
namespace __gnu_cxx
{




  template<typename _Tp>
    struct __aligned_membuf
    {
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/aligned_buffer.h" 3
      alignas(_Tp)

 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()); }
    };
# 95 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/aligned_buffer.h" 3
  template<typename _Tp>
    struct __aligned_buffer
    {

      alignas(__alignof__(_Tp)) unsigned char _M_storage[sizeof(_Tp)];

      __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()); }
    };


}
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/node_handle.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/node_handle.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/node_handle.h" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/node_handle.h" 3
  template<typename _Val, typename _NodeAlloc>
    class _Node_handle_common
    {
      using _AllocTraits = allocator_traits<_NodeAlloc>;

    public:
      using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;

      allocator_type
      get_allocator() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return allocator_type(_M_alloc._M_alloc);
      }

      explicit operator bool() const noexcept { return _M_ptr != nullptr; }

      [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; }


    protected:
      constexpr _Node_handle_common() noexcept : _M_ptr() { }

      ~_Node_handle_common()
      {
 if (!empty())
   _M_reset();
      }

      _Node_handle_common(_Node_handle_common&& __nh) noexcept
      : _M_ptr(__nh._M_ptr)
      {
 if (_M_ptr)
   _M_move(std::move(__nh));
      }

      _Node_handle_common&
      operator=(_Node_handle_common&& __nh) noexcept
      {
 if (empty())
   {
     if (!__nh.empty())
       _M_move(std::move(__nh));
   }
 else if (__nh.empty())
   _M_reset();
 else
   {

     _AllocTraits::destroy(*_M_alloc, _M_ptr->_M_valptr());
     _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);

     _M_alloc = __nh._M_alloc.release();
     _M_ptr = __nh._M_ptr;
     __nh._M_ptr = nullptr;
   }
 return *this;
      }

      _Node_handle_common(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _M_ptr(__ptr), _M_alloc(__alloc)
      {
 do { if (std::__is_constant_evaluated() && !bool(__ptr != nullptr)) std::__glibcxx_assert_fail(); } while (false);
      }

      void
      _M_swap(_Node_handle_common& __nh) noexcept
      {
 if (empty())
   {
     if (!__nh.empty())
       _M_move(std::move(__nh));
   }
 else if (__nh.empty())
   __nh._M_move(std::move(*this));
 else
   {
     using std::swap;
     swap(_M_ptr, __nh._M_ptr);
     _M_alloc.swap(__nh._M_alloc);
   }
      }

    private:



      void
      _M_move(_Node_handle_common&& __nh) noexcept
      {
 ::new (std::__addressof(_M_alloc)) _NodeAlloc(__nh._M_alloc.release());
 _M_ptr = __nh._M_ptr;
 __nh._M_ptr = nullptr;
      }




      void
      _M_reset() noexcept
      {
 _NodeAlloc __alloc = _M_alloc.release();
 _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr());
 _AllocTraits::deallocate(__alloc, _M_ptr, 1);
 _M_ptr = nullptr;
      }




      void
      release() noexcept
      {
 _M_alloc.release();
 _M_ptr = nullptr;
      }

    protected:
      typename _AllocTraits::pointer _M_ptr;

    private:


      union _Optional_alloc
      {
 _Optional_alloc() { }
 ~_Optional_alloc() { }

 _Optional_alloc(_Optional_alloc&&) = delete;
 _Optional_alloc& operator=(_Optional_alloc&&) = delete;

 _Optional_alloc(const _NodeAlloc& __alloc) noexcept
 : _M_alloc(__alloc)
 { }


 void
 operator=(_NodeAlloc&& __alloc) noexcept
 {
   using _ATr = _AllocTraits;
   if constexpr (_ATr::propagate_on_container_move_assignment::value)
     _M_alloc = std::move(__alloc);
   else if constexpr (!_AllocTraits::is_always_equal::value)
     do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __alloc)) std::__glibcxx_assert_fail(); } while (false);
 }


 void
 swap(_Optional_alloc& __other) noexcept
 {
   using std::swap;
   if constexpr (_AllocTraits::propagate_on_container_swap::value)
     swap(_M_alloc, __other._M_alloc);
   else if constexpr (!_AllocTraits::is_always_equal::value)
     do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __other._M_alloc)) std::__glibcxx_assert_fail(); } while (false);
 }


 _NodeAlloc& operator*() noexcept { return _M_alloc; }


 _NodeAlloc release() noexcept
 {
   _NodeAlloc __tmp = std::move(_M_alloc);
   _M_alloc.~_NodeAlloc();
   return __tmp;
 }

 [[__no_unique_address__]] _NodeAlloc _M_alloc;
      };

      [[__no_unique_address__]] _Optional_alloc _M_alloc;

      template<typename _Key2, typename _Value2, typename _KeyOfValue,
        typename _Compare, typename _ValueAlloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;


    };


  template<typename _Key, typename _Value, typename _NodeAlloc>
    class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using key_type = _Key;
      using mapped_type = typename _Value::second_type;

      key_type&
      key() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *_M_pkey;
      }

      mapped_type&
      mapped() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *_M_pmapped;
      }

      void
      swap(_Node_handle& __nh) noexcept
      {
 this->_M_swap(__nh);
 using std::swap;
 swap(_M_pkey, __nh._M_pkey);
 swap(_M_pmapped, __nh._M_pmapped);
      }

      friend void
      swap(_Node_handle& __x, _Node_handle& __y)
      noexcept(noexcept(__x.swap(__y)))
      { __x.swap(__y); }

    private:
      using _AllocTraits = allocator_traits<_NodeAlloc>;

      _Node_handle(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc)
      {
 if (__ptr)
   {
     auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first);
     _M_pkey = _S_pointer_to(__key);
     _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second);
   }
 else
   {
     _M_pkey = nullptr;
     _M_pmapped = nullptr;
   }
      }

      template<typename _Tp>
 using __pointer
   = __ptr_rebind<typename _AllocTraits::pointer,
    remove_reference_t<_Tp>>;

      __pointer<_Key> _M_pkey = nullptr;
      __pointer<typename _Value::second_type> _M_pmapped = nullptr;

      template<typename _Tp>
 __pointer<_Tp>
 _S_pointer_to(_Tp& __obj)
 { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); }

      const key_type&
      _M_key() const noexcept { return key(); }

      template<typename _Key2, typename _Value2, typename _KeyOfValue,
        typename _Compare, typename _ValueAlloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Value, typename _NodeAlloc>
    class _Node_handle<_Value, _Value, _NodeAlloc>
    : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using value_type = _Value;

      value_type&
      value() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_ptr->_M_valptr();
      }

      void
      swap(_Node_handle& __nh) noexcept
      { this->_M_swap(__nh); }

      friend void
      swap(_Node_handle& __x, _Node_handle& __y)
      noexcept(noexcept(__x.swap(__y)))
      { __x.swap(__y); }

    private:
      using _AllocTraits = allocator_traits<_NodeAlloc>;

      _Node_handle(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { }

      const value_type&
      _M_key() const noexcept { return value(); }

      template<typename _Key, typename _Val, typename _KeyOfValue,
        typename _Compare, typename _Alloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Iterator, typename _NodeHandle>
    struct _Node_insert_return
    {
      _Iterator position = _Iterator();
      bool inserted = false;
      _NodeHandle node;
    };




}
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 2 3
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 105 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

    _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 _Base_ptr
    _S_maximum(_Base_ptr __x) noexcept
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }




    _Base_ptr
    _M_base_ptr() const noexcept
    { return const_cast<_Rb_tree_node_base*>(this); }
  };


  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
    {
# 227 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }


      _Rb_tree_node*
      _M_node_ptr() noexcept
      { return this; }
    };


namespace __rb_tree
{
  template<typename _VoidPtr>
    struct _Node_base
    {
      using _Base_ptr = __ptr_rebind<_VoidPtr, _Node_base>;

      _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) __x = __x->_M_left;
 return __x;
      }

      static _Base_ptr
      _S_maximum(_Base_ptr __x) noexcept
      {
 while (__x->_M_right) __x = __x->_M_right;
 return __x;
      }




      _Base_ptr
      _M_base_ptr() const noexcept
      {
 return pointer_traits<_Base_ptr>::pointer_to
   (*const_cast<_Node_base*>(this));
      }
    };


  template<typename _NodeBase>
    struct _Header
    {
    private:
      using _Base_ptr = typename _NodeBase::_Base_ptr;

    public:
      _NodeBase _M_header;
      size_t _M_node_count;

      _Header() noexcept
      {
 _M_header._M_color = _S_red;
 _M_reset();
      }

      _Header(_Header&& __x) noexcept
      {
 if (__x._M_header._M_parent)
   _M_move_data(__x);
 else
   {
     _M_header._M_color = _S_red;
     _M_reset();
   }
      }

      void
      _M_move_data(_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_base_ptr();
 _M_node_count = __from._M_node_count;

 __from._M_reset();
      }

      void
      _M_reset()
      {
 _M_header._M_parent = nullptr;
 _M_header._M_left = _M_header._M_right = _M_header._M_base_ptr();
 _M_node_count = 0;
      }
    };

  template<typename _ValPtr>
    struct _Node : public __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>
    {
      using value_type = typename pointer_traits<_ValPtr>::element_type;
      using _Node_ptr = __ptr_rebind<_ValPtr, _Node>;

      _Node() noexcept { }
      ~_Node() { }
      _Node(_Node&&) = delete;

      union _Uninit_storage
      {
 _Uninit_storage() noexcept { }
 ~_Uninit_storage() { }

 value_type _M_data;
      };
      _Uninit_storage _M_u;

      value_type*
      _M_valptr()
      { return std::addressof(_M_u._M_data); }

      value_type const*
      _M_valptr() const
      { return std::addressof(_M_u._M_data); }

      _Node_ptr
      _M_node_ptr() noexcept
      { return pointer_traits<_Node_ptr>::pointer_to(*this); }
    };
}


  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_decrement(_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_node_base::_Base_ptr _Base_ptr;
      typedef _Rb_tree_node<_Tp>* _Node_ptr;

      _Rb_tree_iterator() noexcept
      : _M_node() { }

      explicit
      _Rb_tree_iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      reference
      operator*() const noexcept
      { return *static_cast<_Node_ptr>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Node_ptr>(_M_node)->_M_valptr(); }

      _Rb_tree_iterator&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Rb_tree_iterator
      operator++(int) noexcept
      {
 _Rb_tree_iterator __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Rb_tree_iterator&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Rb_tree_iterator
      operator--(int) noexcept
      {
 _Rb_tree_iterator __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Rb_tree_iterator& __x,
   const _Rb_tree_iterator& __y) noexcept
      { return __x._M_node == __y._M_node; }
# 441 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      _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_node_base::_Base_ptr _Base_ptr;
      typedef const _Rb_tree_node<_Tp>* _Node_ptr;

      _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) { }

      reference
      operator*() const noexcept
      { return *static_cast<_Node_ptr>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Node_ptr>(_M_node)->_M_valptr(); }

      _Rb_tree_const_iterator&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Rb_tree_const_iterator
      operator++(int) noexcept
      {
 _Rb_tree_const_iterator __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Rb_tree_const_iterator&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Rb_tree_const_iterator
      operator--(int) noexcept
      {
 _Rb_tree_const_iterator __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Rb_tree_const_iterator& __x,
   const _Rb_tree_const_iterator& __y) noexcept
      { return __x._M_node == __y._M_node; }
# 519 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      _Base_ptr _M_node;
    };

  __attribute__((__nonnull__))
  void
  _Rb_tree_insert_and_rebalance(const bool __insert_left,
    _Rb_tree_node_base* __x,
    _Rb_tree_node_base* __p,
    _Rb_tree_node_base& __header) throw ();

  __attribute__((__nonnull__,__returns_nonnull__))
  _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
          _Rb_tree_node_base& __header) throw ();

namespace __rb_tree
{

  template<bool _Const, typename _ValPtr>
    struct _Iterator
    {
      template<typename _Tp>
 using __maybe_const = __conditional_t<_Const, const _Tp, _Tp>;

      using __ptr_traits = pointer_traits<_ValPtr>;
      using value_type = typename __ptr_traits::element_type;
      using reference = __maybe_const<value_type>&;
      using pointer = __maybe_const<value_type>*;

      using iterator_category = bidirectional_iterator_tag;
      using difference_type = ptrdiff_t;

      using _Node = __rb_tree::_Node<_ValPtr>;
      using _Node_base = __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>;
      using _Base_ptr = typename _Node_base::_Base_ptr;

      _Iterator() noexcept
      : _M_node() { }

      constexpr explicit
      _Iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      _Iterator(const _Iterator&) = default;
      _Iterator& operator=(const _Iterator&) = default;


      constexpr
      _Iterator(const _Iterator<false, _ValPtr>& __it) requires _Const






 : _M_node(__it._M_node) { }

      [[__nodiscard__]]
      reference
      operator*() const noexcept
      { return *static_cast<_Node&>(*_M_node)._M_valptr(); }

      [[__nodiscard__]]
      pointer
      operator->() const noexcept
      { return static_cast<_Node&>(*_M_node)._M_valptr(); }

      constexpr _Iterator&
      operator++() noexcept
      {
 if (_M_node->_M_right)
   {
     _M_node = _M_node->_M_right;
     while (_M_node->_M_left)
       _M_node = _M_node->_M_left;
   }
 else
   {
     _Base_ptr __y = _M_node->_M_parent;
     while (_M_node == __y->_M_right)
       {
  _M_node = __y;
  __y = __y->_M_parent;
       }
     if (_M_node->_M_right != __y)
       _M_node = __y;
   }

 return *this;
      }

      constexpr _Iterator
      operator++(int) noexcept
      {
 _Iterator __tmp(this->_M_node);
 ++*this;
 return __tmp;
      }

      constexpr _Iterator&
      operator--() noexcept
      {
 if (_M_node->_M_color == _S_red
     && _M_node->_M_parent->_M_parent == _M_node)
   _M_node = _M_node->_M_right;
 else if (_M_node->_M_left)
   {
     _Base_ptr __y = _M_node->_M_left;
     while (__y->_M_right)
       __y = __y->_M_right;
     _M_node = __y;
   }
 else
   {
     _Base_ptr __y = _M_node->_M_parent;
     while (_M_node == __y->_M_left)
       {
  _M_node = __y;
  __y = __y->_M_parent;
       }
     _M_node = __y;
   }
 return *this;
      }

      constexpr _Iterator
      operator--(int) noexcept
      {
 _Iterator __tmp(this->_M_node);
 --*this;
 return __tmp;
      }

      [[__nodiscard__]]
      friend bool
      operator==(const _Iterator& __x, const _Iterator& __y) noexcept
      { return __x._M_node == __y._M_node; }
# 664 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      _Base_ptr _M_node;
    };



  template<typename _Val, typename _Ptr>
    struct _Node_traits;





  template<typename _Val>
    struct _Node_traits<_Val, _Val*>
    {
      typedef _Rb_tree_node<_Val> _Node;
      typedef _Node* _Node_ptr;
      typedef _Rb_tree_node_base _Node_base;
      typedef _Node_base* _Base_ptr;
      typedef _Rb_tree_header _Header_t;
      typedef _Rb_tree_iterator<_Val> _Iterator;
      typedef _Rb_tree_const_iterator<_Val> _Const_iterator;

      __attribute__((__nonnull__))
      static void
      _S_insert_and_rebalance(const bool __insert_left,
         _Node_base* __x, _Node_base* __p,
         _Node_base& __header) noexcept
      {
 return _Rb_tree_insert_and_rebalance(__insert_left, __x, __p, __header);
      }

      __attribute__((__nonnull__,__returns_nonnull__))
      static _Node_base*
      _S_rebalance_for_erase(_Node_base* const __z,
        _Node_base& __header) noexcept
      { return _Rb_tree_rebalance_for_erase(__z, __header); }
    };
# 712 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
  template<typename _Val, typename _ValPtr>
    struct _Node_traits
    {
      using _Node = __rb_tree::_Node<_ValPtr>;
      using _Node_ptr = __ptr_rebind<_ValPtr, _Node>;
      using _Node_base = __rb_tree::_Node_base<__ptr_rebind<_ValPtr, void>>;
      using _Base_ptr = __ptr_rebind<_ValPtr, _Node_base>;
      using _Header_t = __rb_tree::_Header<_Node_base>;
      using _Iterator = __rb_tree::_Iterator<false, _ValPtr>;
      using _Const_iterator = __rb_tree::_Iterator<true, _ValPtr>;

      static void
      _Rotate_left(_Base_ptr __x, _Base_ptr& __root)
      {
 const _Base_ptr __y = __x->_M_right;

 __x->_M_right = __y->_M_left;
 if (__y->_M_left)
   __y->_M_left->_M_parent = __x;
 __y->_M_parent = __x->_M_parent;

 if (__x == __root)
   __root = __y;
 else if (__x == __x->_M_parent->_M_left)
   __x->_M_parent->_M_left = __y;
 else
   __x->_M_parent->_M_right = __y;
 __y->_M_left = __x;
 __x->_M_parent = __y;
      }

      static void
      _Rotate_right(_Base_ptr __x, _Base_ptr& __root)
      {
 const _Base_ptr __y = __x->_M_left;

 __x->_M_left = __y->_M_right;
 if (__y->_M_right)
   __y->_M_right->_M_parent = __x;
 __y->_M_parent = __x->_M_parent;

 if (__x == __root)
   __root = __y;
 else if (__x == __x->_M_parent->_M_right)
   __x->_M_parent->_M_right = __y;
 else
   __x->_M_parent->_M_left = __y;
 __y->_M_right = __x;
 __x->_M_parent = __y;
      }

      static void
      _S_insert_and_rebalance(const bool __insert_left,
         _Base_ptr __x, _Base_ptr __p,
         _Node_base& __header)
      {
 _Base_ptr& __root = __header._M_parent;


 __x->_M_parent = __p;
 __x->_M_left = __x->_M_right = nullptr;
 __x->_M_color = _S_red;





 if (__insert_left)
   {
     __p->_M_left = __x;

     if (std::__to_address(__p) == std::addressof(__header))
       {
  __header._M_parent = __x;
  __header._M_right = __x;
       }
     else if (__p == __header._M_left)
       __header._M_left = __x;
   }
 else
   {
     __p->_M_right = __x;

     if (__p == __header._M_right)
       __header._M_right = __x;
   }

 while (__x != __root
        && __x->_M_parent->_M_color == _S_red)
   {
     const _Base_ptr __xpp = __x->_M_parent->_M_parent;

     if (__x->_M_parent == __xpp->_M_left)
       {
  const _Base_ptr __y = __xpp->_M_right;
  if (__y && __y->_M_color == _S_red)
    {
      __x->_M_parent->_M_color = _S_black;
      __y->_M_color = _S_black;
      __xpp->_M_color = _S_red;
      __x = __xpp;
    }
  else
    {
      if (__x == __x->_M_parent->_M_right)
        {
   __x = __x->_M_parent;
   _Rotate_left(__x, __root);
        }
      __x->_M_parent->_M_color = _S_black;
      __xpp->_M_color = _S_red;
      _Rotate_right(__xpp, __root);
    }
       }
     else
       {
  const _Base_ptr __y = __xpp->_M_left;
  if (__y && __y->_M_color == _S_red)
    {
      __x->_M_parent->_M_color = _S_black;
      __y->_M_color = _S_black;
      __xpp->_M_color = _S_red;
      __x = __xpp;
    }
  else
    {
      if (__x == __x->_M_parent->_M_left)
        {
   __x = __x->_M_parent;
   _Rotate_right(__x, __root);
        }
      __x->_M_parent->_M_color = _S_black;
      __xpp->_M_color = _S_red;
      _Rotate_left(__xpp, __root);
    }
       }
   }
 __root->_M_color = _S_black;
      }

      static _Base_ptr
      _S_rebalance_for_erase(_Base_ptr __z, _Node_base& __header)
      {
 _Base_ptr& __root = __header._M_parent;
 _Base_ptr& __leftmost = __header._M_left;
 _Base_ptr& __rightmost = __header._M_right;
 _Base_ptr __y = __z;
 _Base_ptr __x{};
 _Base_ptr __x_parent{};

 if (!__y->_M_left)
   __x = __y->_M_right;
 else
   if (!__y->_M_right)
     __x = __y->_M_left;
   else
     {

       __y = __y->_M_right;
       while (__y->_M_left)
  __y = __y->_M_left;
       __x = __y->_M_right;
     }
 if (__y != __z)
   {

     __z->_M_left->_M_parent = __y;
     __y->_M_left = __z->_M_left;
     if (__y != __z->_M_right)
       {
  __x_parent = __y->_M_parent;
  if (__x)
    __x->_M_parent = __y->_M_parent;
  __y->_M_parent->_M_left = __x;
  __y->_M_right = __z->_M_right;
  __z->_M_right->_M_parent = __y;
       }
     else
       __x_parent = __y;
     if (__root == __z)
       __root = __y;
     else if (__z->_M_parent->_M_left == __z)
       __z->_M_parent->_M_left = __y;
     else
       __z->_M_parent->_M_right = __y;
     __y->_M_parent = __z->_M_parent;
     std::swap(__y->_M_color, __z->_M_color);
     __y = __z;

   }
 else
   {
     __x_parent = __y->_M_parent;
     if (__x)
       __x->_M_parent = __y->_M_parent;
     if (__root == __z)
       __root = __x;
     else
       if (__z->_M_parent->_M_left == __z)
  __z->_M_parent->_M_left = __x;
       else
  __z->_M_parent->_M_right = __x;
     if (__leftmost == __z)
       {
  if (!__z->_M_right)
    __leftmost = __z->_M_parent;

  else
    __leftmost = _Node_base::_S_minimum(__x);
       }
     if (__rightmost == __z)
       {
  if (__z->_M_left == 0)
    __rightmost = __z->_M_parent;

  else
    __rightmost = _Node_base::_S_maximum(__x);
       }
   }
 if (__y->_M_color != _S_red)
   {
     while (__x != __root && (__x == 0 || __x->_M_color == _S_black))
       if (__x == __x_parent->_M_left)
  {
    _Base_ptr __w = __x_parent->_M_right;
    if (__w->_M_color == _S_red)
      {
        __w->_M_color = _S_black;
        __x_parent->_M_color = _S_red;
        _Rotate_left(__x_parent, __root);
        __w = __x_parent->_M_right;
      }
    if ((!__w->_M_left || __w->_M_left->_M_color == _S_black) &&
        (!__w->_M_right || __w->_M_right->_M_color == _S_black))
      {
        __w->_M_color = _S_red;
        __x = __x_parent;
        __x_parent = __x_parent->_M_parent;
      }
    else
      {
        if (!__w->_M_right || __w->_M_right->_M_color == _S_black)
   {
     __w->_M_left->_M_color = _S_black;
     __w->_M_color = _S_red;
     _Rotate_right(__w, __root);
     __w = __x_parent->_M_right;
   }
        __w->_M_color = __x_parent->_M_color;
        __x_parent->_M_color = _S_black;
        if (__w->_M_right)
   __w->_M_right->_M_color = _S_black;
        _Rotate_left(__x_parent, __root);
        break;
      }
  }
       else
  {

    _Base_ptr __w = __x_parent->_M_left;
    if (__w->_M_color == _S_red)
      {
        __w->_M_color = _S_black;
        __x_parent->_M_color = _S_red;
        _Rotate_right(__x_parent, __root);
        __w = __x_parent->_M_left;
      }
    if ((!__w->_M_right || __w->_M_right->_M_color == _S_black) &&
        (!__w->_M_left || __w->_M_left->_M_color == _S_black))
      {
        __w->_M_color = _S_red;
        __x = __x_parent;
        __x_parent = __x_parent->_M_parent;
      }
    else
      {
        if (!__w->_M_left || __w->_M_left->_M_color == _S_black)
   {
     __w->_M_right->_M_color = _S_black;
     __w->_M_color = _S_red;
     _Rotate_left(__w, __root);
     __w = __x_parent->_M_left;
   }
        __w->_M_color = __x_parent->_M_color;
        __x_parent->_M_color = _S_black;
        if (__w->_M_left)
   __w->_M_left->_M_color = _S_black;
        _Rotate_right(__x_parent, __root);
        break;
      }
  }
     if (__x)
       __x->_M_color = _S_black;
   }

 return __y;
      }
    };

}


  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<_Val>::other _Val_alloc_type;

      typedef __gnu_cxx::__alloc_traits<_Val_alloc_type> _Val_alloc_traits;
      typedef typename _Val_alloc_traits::pointer _ValPtr;
      typedef __rb_tree::_Node_traits<_Val, _ValPtr> _Node_traits;

      typedef typename _Node_traits::_Node_base _Node_base;
      typedef typename _Node_traits::_Node _Node;

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Node>::other _Node_allocator;

      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Node_alloc_traits;

    protected:
      typedef typename _Node_traits::_Base_ptr _Base_ptr;
      typedef typename _Node_traits::_Node_ptr _Node_ptr;

    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 = _Base_ptr();

       if (_M_nodes->_M_left)
  _M_nodes = _M_nodes->_M_left;
     }
   else
     _M_nodes = _Base_ptr();
 }


 _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;


 ~_Reuse_or_alloc_node()
 {
   if (_M_root)
     _M_t._M_erase(static_cast<_Node&>(*_M_root)._M_node_ptr());
 }

 template<typename _Arg>
   _Node_ptr
   operator()(_Arg&& __arg)
   {
     _Base_ptr __base = _M_extract();
     if (__base)
       {
  _Node_ptr __node = static_cast<_Node&>(*__base)._M_node_ptr();
  _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 = _Base_ptr();

    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 = _Base_ptr();
     }
   else
     _M_root = _Base_ptr();

   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>
   _Node_ptr
   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:
      _Node_ptr
      _M_get_node()
      {

 return _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1);
# 1185 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      }

      void
      _M_put_node(_Node_ptr __p) noexcept
      {

 _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1);
# 1207 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      }
# 1230 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      template<typename... _Args>
 void
 _M_construct_node(_Node_ptr __node, _Args&&... __args)
 {
   try
     {
       ::new(std::addressof(*__node)) _Node;
       _Node_alloc_traits::construct(_M_get_Node_allocator(),
         __node->_M_valptr(),
         std::forward<_Args>(__args)...);
     }
   catch(...)
     {
       __node->~_Node();
       _M_put_node(__node);
       throw;
     }
 }

      template<typename... _Args>
 _Node_ptr
 _M_create_node(_Args&&... __args)
 {
   _Node_ptr __tmp = _M_get_node();
   _M_construct_node(__tmp, std::forward<_Args>(__args)...);
   return __tmp;
 }


      void
      _M_destroy_node(_Node_ptr __p) noexcept
      {



 _Node_alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
 __p->~_Node();

      }

      void
      _M_drop_node(_Node_ptr __p) noexcept
      {
 _M_destroy_node(__p);
 _M_put_node(__p);
      }

      template<bool _MoveValue, typename _NodeGen>
 _Node_ptr
 _M_clone_node(_Node_ptr __x, _NodeGen& __node_gen)
 {

   using _Vp = __conditional_t<_MoveValue,
          value_type&&,
          const value_type&>;

   _Node_ptr __tmp
     = __node_gen(std::forward<_Vp>(*__x->_M_valptr()));
   __tmp->_M_color = __x->_M_color;
   __tmp->_M_left = __tmp->_M_right = _Base_ptr();
   return __tmp;
 }

    protected:
      typedef typename _Node_traits::_Header_t _Header_t;





      template<typename _Key_compare,
        bool = __is_pod(_Key_compare)>

 struct _Rb_tree_impl
 : public _Node_allocator
 , public _Rb_tree_key_compare<_Key_compare>
 , public _Header_t
 {
   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(_Node_alloc_traits::_S_select_on_copy(__x))
   , _Base_key_compare(__x._M_key_compare)
   , _Header_t()
   { }






   _Rb_tree_impl(_Rb_tree_impl&&)
     noexcept( is_nothrow_move_constructible<_Base_key_compare>::value )
   = default;

   explicit
   _Rb_tree_impl(_Node_allocator&& __a)
   : _Node_allocator(std::move(__a))
   { }

   _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
   : _Node_allocator(std::move(__a)),
     _Base_key_compare(std::move(__x)),
     _Header_t(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; }

      _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; }

      _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; }

      _Base_ptr
      _M_rightmost() const noexcept
      { return this->_M_impl._M_header._M_right; }

      _Base_ptr
      _M_begin() const noexcept
      { return this->_M_impl._M_header._M_parent; }

      _Node_ptr
      _M_begin_node() const noexcept
      {
 _Base_ptr __begin = this->_M_impl._M_header._M_parent;
 return __begin
   ? static_cast<_Node&>(*__begin)._M_node_ptr()
   : _Node_ptr();
      }

      _Base_ptr
      _M_end() const noexcept
      { return this->_M_impl._M_header._M_base_ptr(); }

      static const _Key&
      _S_key(const _Node& __node)
      {



 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()(*__node._M_valptr());
      }

      static const _Key&
      _S_key(_Base_ptr __x)
      { return _S_key(static_cast<const _Node&>(*__x)); }

      static const _Key&
      _S_key(_Node_ptr __x)
      { return _S_key(*__x); }

      static _Base_ptr
      _S_left(_Base_ptr __x) noexcept
      { return __x->_M_left; }

      static _Node_ptr
      _S_left(_Node_ptr __x)
      {
 return __x->_M_left
   ? static_cast<_Node&>(*__x->_M_left)._M_node_ptr()
   : _Node_ptr();
      }

      static _Base_ptr
      _S_right(_Base_ptr __x) noexcept
      { return __x->_M_right; }

      static _Node_ptr
      _S_right(_Node_ptr __x) noexcept
      {
 return __x->_M_right
   ? static_cast<_Node&>(*__x->_M_right)._M_node_ptr()
   : _Node_ptr();
      }

    public:
      typedef typename _Node_traits::_Iterator iterator;
      typedef typename _Node_traits::_Const_iterator 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, _Node_ptr __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, _Node_ptr __z);

      iterator
      _M_insert_equal_lower_node(_Node_ptr __z);
# 1512 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      enum { __as_lvalue, __as_rvalue };

      template<bool _MoveValues, typename _NodeGen>
 _Base_ptr
 _M_copy(_Node_ptr, _Base_ptr, _NodeGen&);

      template<bool _MoveValues, typename _NodeGen>
 _Base_ptr
 _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
 {
   _Base_ptr __root =
     _M_copy<_MoveValues>(__x._M_begin_node(), _M_end(), __gen);
   _M_leftmost() = _Node_base::_S_minimum(__root);
   _M_rightmost() = _Node_base::_S_maximum(__root);
   _M_impl._M_node_count = __x._M_impl._M_node_count;
   return __root;
 }

      _Base_ptr
      _M_copy(const _Rb_tree& __x)
      {
 _Alloc_node __an(*this);
 return _M_copy<__as_lvalue>(__x, __an);
      }

      void
      _M_erase(_Node_ptr __x);

      _Base_ptr
      _M_lower_bound(_Base_ptr __x, _Base_ptr __y,
       const _Key& __k) const;

      _Base_ptr
      _M_upper_bound(_Base_ptr __x, _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())
   _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())
   _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())
   _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 _Node_alloc_traits::is_always_equal>())) )
      : _Rb_tree(std::move(__x), std::move(__a),
   typename _Node_alloc_traits::is_always_equal{})
      { }


      ~_Rb_tree() noexcept
      { _M_erase(_M_begin_node()); }

      _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(_M_end()); }

      const_iterator
      end() const noexcept
      { return const_iterator(_M_end()); }

      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 _Node_alloc_traits::max_size(_M_get_Node_allocator()); }

      void
      swap(_Rb_tree& __t)
      noexcept(__is_nothrow_swappable<_Compare>::value);



      template<typename _Arg>
 pair<iterator, bool>
 _M_insert_unique(_Arg&& __x);

      template<typename _Arg>
 iterator
 _M_insert_equal(_Arg&& __x);

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename... _Args>
 pair<iterator, bool>
 _M_emplace_unique(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_equal(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);

      template<typename _Iter>
 using __same_value_type
   = is_same<value_type, typename iterator_traits<_Iter>::value_type>;

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_unique_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   for (; __first != __last; ++__first)
     _M_emplace_unique(*__first);
 }

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_equal_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   for (; __first != __last; ++__first)
     _M_emplace_equal(*__first);
 }
# 1803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
    private:
      void
      _M_erase_aux(const_iterator __position);

      void
      _M_erase_aux(const_iterator __first, const_iterator __last);

    public:



      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      {
 do { if (std::__is_constant_evaluated() && !bool(__position != end())) std::__glibcxx_assert_fail(); } while (false);
 const_iterator __result = __position;
 ++__result;
 _M_erase_aux(__position);
 return iterator(__result._M_node);
      }


      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(iterator __position)
      {
 do { if (std::__is_constant_evaluated() && !bool(__position != end())) std::__glibcxx_assert_fail(); } while (false);
 iterator __result = __position;
 ++__result;
 _M_erase_aux(__position);
 return __result;
      }
# 1852 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 iterator(__last._M_node);
      }
# 1875 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      void
      clear() noexcept
      {
 _M_erase(_M_begin_node());
 _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 iterator(_M_lower_bound(_M_begin(), _M_end(), __k)); }

      const_iterator
      lower_bound(const key_type& __k) const
      {
 return const_iterator
   (_M_lower_bound(_M_begin(), _M_end(), __k));
      }

      iterator
      upper_bound(const key_type& __k)
      { return iterator(_M_upper_bound(_M_begin(), _M_end(), __k)); }

      const_iterator
      upper_bound(const key_type& __k) const
      {
 return const_iterator
   (_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 iterator(__const_this->_M_find_tr(__k)._M_node);
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 const_iterator
 _M_find_tr(const _Kt& __k) const
 {
   const_iterator __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>>
 _Base_ptr
 _M_lower_bound_tr(const _Kt& __k) const
 {
   auto __x = _M_begin();
   auto __y = _M_end();
   while (__x)
     if (!_M_impl._M_key_compare(_S_key(__x), __k))
       {
  __y = __x;
  __x = _S_left(__x);
       }
     else
       __x = _S_right(__x);
   return __y;
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 _Base_ptr
 _M_upper_bound_tr(const _Kt& __k) const
 {
   auto __x = _M_begin();
   auto __y = _M_end();
   while (__x)
     if (_M_impl._M_key_compare(__k, _S_key(__x)))
       {
  __y = __x;
  __x = _S_left(__x);
       }
     else
       __x = _S_right(__x);
   return __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
     { iterator(__ret.first._M_node), iterator(__ret.second._M_node) };
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 pair<const_iterator, const_iterator>
 _M_equal_range_tr(const _Kt& __k) const
 {
   const_iterator __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(_Node_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);



      static _Node_ptr
      _S_adapt(typename _Node_alloc_traits::pointer __ptr)
      {

 return __ptr;
# 2066 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      }

    public:

      insert_return_type
      _M_reinsert_node_unique(node_type&& __nh)
      {
 insert_return_type __ret;
 if (__nh.empty())
   __ret.position = end();
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocator() == *__nh._M_alloc)) std::__glibcxx_assert_fail(); } while (false);

     auto __res = _M_get_insert_unique_pos(__nh._M_key());
     if (__res.second)
       {
  __ret.position
    = _M_insert_node(__res.first, __res.second,
       _S_adapt(__nh._M_ptr));
  __nh.release();
  __ret.inserted = true;
       }
     else
       {
  __ret.node = std::move(__nh);
  __ret.position = iterator(__res.first);
  __ret.inserted = false;
       }
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_equal(node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocator() == *__nh._M_alloc)) std::__glibcxx_assert_fail(); } while (false);
     auto __res = _M_get_insert_equal_pos(__nh._M_key());
     if (__res.second)
       __ret = _M_insert_node(__res.first, __res.second,
         _S_adapt(__nh._M_ptr));
     else
       __ret = _M_insert_equal_lower_node(_S_adapt(__nh._M_ptr));
     __nh.release();
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocator() == *__nh._M_alloc)) std::__glibcxx_assert_fail(); } while (false);
     auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key());
     if (__res.second)
       {
  __ret = _M_insert_node(__res.first, __res.second,
           _S_adapt(__nh._M_ptr));
  __nh.release();
       }
     else
       __ret = iterator(__res.first);
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(_M_get_Node_allocator() == *__nh._M_alloc)) std::__glibcxx_assert_fail(); } while (false);
     auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key());
     if (__res.second)
       __ret = _M_insert_node(__res.first, __res.second,
         _S_adapt(__nh._M_ptr));
     else
       __ret = _M_insert_equal_lower_node(_S_adapt(__nh._M_ptr));
     __nh.release();
   }
 return __ret;
      }


      node_type
      extract(const_iterator __pos)
      {
 auto __ptr = _Node_traits::_S_rebalance_for_erase
   (__pos._M_node, _M_impl._M_header);
 --_M_impl._M_node_count;
 auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();

 return { __node_ptr, _M_get_Node_allocator() };
# 2187 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
      }


      node_type
      extract(const key_type& __k)
      {
 node_type __nh;
 auto __pos = find(__k);
 if (__pos != end())
   __nh = extract(const_iterator(__pos));
 return __nh;
      }

      template<typename _Compare2>
 using _Compatible_tree
   = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;

      template<typename, typename>
 friend struct _Rb_tree_merge_helper;


      template<typename _Compare2>
 void
 _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
 {
   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
       if (__res.second)
  {
    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
    auto __ptr = _Node_traits::_S_rebalance_for_erase
      (__pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();
    _M_insert_node(__res.first, __res.second, __node_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 = _Node_traits::_S_rebalance_for_erase
      (__pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    auto __node_ptr = static_cast<_Node&>(*__ptr)._M_node_ptr();
    _M_insert_node(__res.first, __res.second, __node_ptr);
  }
     }
 }


      friend bool
      operator==(const _Rb_tree& __x, const _Rb_tree& __y)
      {
 return __x.size() == __y.size()
   && std::equal(__x.begin(), __x.end(), __y.begin());
      }


      friend auto
      operator<=>(const _Rb_tree& __x, const _Rb_tree& __y)
      {
 if constexpr (requires { typename __detail::__synth3way_t<_Val>; })
   return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
       __y.begin(), __y.end(),
       __detail::__synth3way);
      }
# 2277 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tree.h" 3
    private:


      struct _Auto_node
      {
 template<typename... _Args>
   _Auto_node(_Rb_tree& __t, _Args&&... __args)
   : _M_t(__t),
     _M_node(__t._M_create_node(std::forward<_Args>(__args)...))
   { }

 ~_Auto_node()
 {
   if (_M_node)
     _M_t._M_drop_node(_M_node);
 }

 _Auto_node(_Auto_node&& __n)
 : _M_t(__n._M_t), _M_node(__n._M_node)
 { __n._M_node = nullptr; }

 const _Key&
 _M_key() const
 { return _S_key(_M_node); }

 iterator
 _M_insert(pair<_Base_ptr, _Base_ptr> __p)
 {
   auto __it = _M_t._M_insert_node(__p.first, __p.second, _M_node);
   _M_node = nullptr;
   return __it;
 }

 iterator
 _M_insert_equal_lower()
 {
   auto __it = _M_t._M_insert_equal_lower_node(_M_node);
   _M_node = nullptr;
   return __it;
 }

 _Rb_tree& _M_t;
 _Node_ptr _M_node;
      };

    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_data(_Rb_tree& __x, false_type)
    {
      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
 _M_move_data(__x, true_type());
      else
 {
   constexpr bool __move = !__move_if_noexcept_cond<value_type>::value;
   _Alloc_node __an(*this);
   _M_root() = _M_copy<__move>(__x, __an);
   if constexpr (__move)
     __x.clear();
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_assign(_Rb_tree& __x, true_type)
    {
      clear();
      if (__x._M_root())
 _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())
 {
   _M_root() = _M_copy<__as_rvalue>(__x, __roan);
   __x.clear();
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(_Rb_tree&& __x)
    noexcept(_Node_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<_Node_alloc_traits::_S_nothrow_move()>());
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_unique(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first, __roan);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_equal(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first, __roan);
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree& __x)
    {
      if (this != std::__addressof(__x))
 {


   if (_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);
  }
     }


   _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())
     _M_root() = _M_copy<__as_lvalue>(__x, __roan);
 }

      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_(_Base_ptr __x, _Base_ptr __p,

   _Arg&& __v,



   _NodeGen& __node_gen)
      {
 bool __insert_left = (__x || __p == _M_end()
         || _M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key(__p)));

 _Base_ptr __z =
   __node_gen(std::forward<_Arg>(__v))->_M_base_ptr();

 _Node_traits::_S_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)));

      _Base_ptr __z =
 _M_create_node(std::forward<_Arg>(__v))->_M_base_ptr();
      _Node_traits::_S_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)



    {
      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower(__y, std::forward<_Arg>(__v));
    }

  template<typename _Key, typename _Val, typename _KoV,
    typename _Compare, typename _Alloc>
    template<bool _MoveValues, typename _NodeGen>
      typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Base_ptr
      _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
      _M_copy(_Node_ptr __x, _Base_ptr __p, _NodeGen& __node_gen)
      {

 _Node_ptr __top = _M_clone_node<_MoveValues>(__x, __node_gen);
 _Base_ptr __top_base = __top->_M_base_ptr();
 __top->_M_parent = __p;

 try
   {
     if (__x->_M_right)
       __top->_M_right =
  _M_copy<_MoveValues>(_S_right(__x), __top_base, __node_gen);
     __p = __top_base;
     __x = _S_left(__x);

     while (__x)
       {
  _Base_ptr __y =
    _M_clone_node<_MoveValues>(__x, __node_gen)->_M_base_ptr();
  __p->_M_left = __y;
  __y->_M_parent = __p;
  if (__x->_M_right)
    __y->_M_right = _M_copy<_MoveValues>(_S_right(__x),
             __y, __node_gen);
  __p = __y;
  __x = _S_left(__x);
       }
   }
 catch(...)
   {
     _M_erase(__top);
     throw;
   }
 return __top_base;
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase(_Node_ptr __x)
    {

      while (__x)
 {
   _M_erase(_S_right(__x));
   _Node_ptr __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>::_Base_ptr
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Base_ptr __x, _Base_ptr __y,
     const _Key& __k) const
    {
      while (__x)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return __y;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::_Base_ptr
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Base_ptr __x, _Base_ptr __y,
     const _Key& __k) const
    {
      while (__x)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return __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)
    {
      typedef pair<iterator, iterator> _Ret;

      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x)
 {
   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
     {
       _Base_ptr __xu(__x);
       _Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return _Ret(iterator(_M_lower_bound(__x, __y, __k)),
     iterator(_M_upper_bound(__xu, __yu, __k)));
     }
 }
      return _Ret(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
    {
      typedef pair<const_iterator, const_iterator> _Ret;

      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x)
 {
   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
     {
       _Base_ptr __xu(__x);
       _Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return _Ret(const_iterator(_M_lower_bound(__x, __y, __k)),
     const_iterator(_M_upper_bound(__xu, __yu, __k)));
     }
 }
      return _Ret(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())
 {
   if (__t._M_root())
     _M_impl._M_move_data(__t._M_impl);
 }
      else if (!__t._M_root())
 __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);
 }


      using std::swap;
      swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);

      _Node_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;
      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      bool __comp = true;
      while (__x)
 {
   __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, _Base_ptr());
    }

  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;
      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x)
 {
   __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)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
     return _Res(_Base_ptr(), _M_rightmost());
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(__k, _S_key(__position._M_node)))
 {

   iterator __before(__position._M_node);
   if (__position._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))
  return _Res(_Base_ptr(), __before._M_node);
       else
  return _Res(__position._M_node, __position._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(_S_key(__position._M_node), __k))
 {

   iterator __after(__position._M_node);
   if (__position._M_node == _M_rightmost())
     return _Res(_Base_ptr(), _M_rightmost());
   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
     {
       if (!_S_right(__position._M_node))
  return _Res(_Base_ptr(), __position._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else

 return _Res(__position._M_node, _Base_ptr());
    }

  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)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
     return _Res(_Base_ptr(), _M_rightmost());
   else
     return _M_get_insert_equal_pos(__k);
 }
      else if (!_M_impl._M_key_compare(_S_key(__position._M_node), __k))
 {

   iterator __before(__position._M_node);
   if (__position._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))
  return _Res(_Base_ptr(), __before._M_node);
       else
  return _Res(__position._M_node, __position._M_node);
     }
   else
     return _M_get_insert_equal_pos(__k);
 }
      else
 {

   iterator __after(__position._M_node);
   if (__position._M_node == _M_rightmost())
     return _Res(_Base_ptr(), _M_rightmost());
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
     {
       if (!_S_right(__position._M_node))
  return _Res(_Base_ptr(), __position._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _Res(_Base_ptr(), _Base_ptr());
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_equal_(const_iterator __position,

         _Arg&& __v,



         _NodeGen& __node_gen)
      {
 pair<_Base_ptr, _Base_ptr> __res
   = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));

 if (__res.second)
   return _M_insert_(__res.first, __res.second,
       std::forward<_Arg>(__v),
       __node_gen);

 return _M_insert_equal_lower(std::forward<_Arg>(__v));
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Node_ptr __z)
    -> iterator
    {
      bool __insert_left = (__x || __p == _M_end()
       || _M_impl._M_key_compare(_S_key(__z),
            _S_key(__p)));

      _Base_ptr __base_z = __z->_M_base_ptr();
      _Node_traits::_S_insert_and_rebalance
 (__insert_left, __base_z, __p, this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__base_z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_lower_node(_Base_ptr __p, _Node_ptr __z)
    -> iterator
    {
      bool __insert_left = (__p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _S_key(__z)));

      _Base_ptr __base_z = __z->_M_base_ptr();
      _Node_traits::_S_insert_and_rebalance
 (__insert_left, __base_z, __p, this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__base_z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_lower_node(_Node_ptr __z)
    -> iterator
    {
      _Base_ptr __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower_node(__y, __z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_unique(_Args&&... __args)
      -> pair<iterator, bool>
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_unique_pos(__z._M_key());
 if (__res.second)
   return {__z._M_insert(__res), true};
 return {iterator(__res.first), false};
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_equal(_Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_equal_pos(__z._M_key());
 return __z._M_insert(__res);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_hint_unique_pos(__pos, __z._M_key());
 if (__res.second)
   return __z._M_insert(__res);
 return iterator(__res.first);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_hint_equal_pos(__pos, __z._M_key());
 if (__res.second)
   return __z._M_insert(__res);
 return __z._M_insert_equal_lower();
      }



  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase_aux(const_iterator __position)
    {
      _Base_ptr __y = _Node_traits::_S_rebalance_for_erase
 (__position._M_node, this->_M_impl._M_header);
      _M_drop_node(static_cast<_Node&>(*__y)._M_node_ptr());
      --_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)
 {
   _Base_ptr __x = __it._M_node;
   _Base_ptr __L = _S_left(__x);
   _Base_ptr __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() != _Node_base::_S_minimum(_M_root()))
 return false;
      if (_M_rightmost() != _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; }
    };



}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 1 3
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class multimap;
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::map must have the same value_type as its allocator");



    public:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class map<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };
#pragma GCC diagnostic pop

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;


      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;


      template<typename _Up, typename _Vp = remove_reference_t<_Up>>
 static constexpr bool __usable_key
   = __or_v<is_same<const _Vp, const _Key>,
     __and_<is_scalar<_Vp>, is_scalar<_Key>>>;


    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;


      using node_type = typename _Rep_type::node_type;
      using insert_return_type = typename _Rep_type::insert_return_type;
# 200 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)) { }
# 222 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      map(const map&) = default;







      map(map&&) = default;
# 243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      map(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      map(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      map(const map& __m, const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      map(map&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      map(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 287 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 304 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 337 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      ~map() = default;
# 353 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      map&
      operator=(const map&) = default;


      map&
      operator=(map&&) = default;
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 526 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 571 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 609 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 {

   if constexpr (sizeof...(_Args) == 2)
     if constexpr (is_same_v<allocator_type, allocator<value_type>>)
       {
  auto&& [__a, __v] = pair<_Args&...>(__args...);
  if constexpr (__usable_key<decltype(__a)>)
    {
      const key_type& __k = __a;
      iterator __i = lower_bound(__k);
      if (__i == end() || key_comp()(__k, (*__i).first))
        {
   __i = emplace_hint(__i, std::forward<_Args>(__args)...);
   return {__i, true};
        }
      return {__i, false};
    }
       }

   return _M_t._M_emplace_unique(std::forward<_Args>(__args)...);
 }
# 659 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_unique(__pos,
          std::forward<_Args>(__args)...);
 }




      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 743 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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};
 }
# 803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
 }
# 856 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }




      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_t._M_insert_unique(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value,
        pair<iterator, bool>>
 insert(_Pair&& __x)
 {

   using _P2 = remove_reference_t<_Pair>;
   if constexpr (__is_pair<remove_const_t<_P2>>)
     if constexpr (is_same_v<allocator_type, allocator<value_type>>)
       if constexpr (__usable_key<typename _P2::first_type>)
  {
    const key_type& __k = __x.first;
    iterator __i = lower_bound(__k);
    if (__i == end() || key_comp()(__k, (*__i).first))
      {
        __i = emplace_hint(__i, std::forward<_Pair>(__x));
        return {__i, true};
      }
    return {__i, false};
  }

   return _M_t._M_emplace_unique(std::forward<_Pair>(__x));
 }
# 901 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      void
      insert(std::initializer_list<value_type> __list)
      { insert(__list.begin(), __list.end()); }
# 948 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
 }
# 981 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 1006 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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};
 }
# 1061 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
 }
# 1120 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 1177 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 1211 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1258 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1283 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1304 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_t._M_find_tr(__x), void(), true)
 { return _M_t._M_find_tr(__x) != _M_t.end(); }
# 1347 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1372 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1392 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1412 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1441 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const map<_K1, _T1, _C1, _A1>&,
     const map<_K1, _T1, _C1, _A1>&);


      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<pair<const _K1, _T1>>
 operator<=>(const map<_K1, _T1, _C1, _A1>&,
      const map<_K1, _T1, _C1, _A1>&);






    };




  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<_Key, _Tp, _Compare, _Allocator>;

  template <typename _InputIterator, typename _Allocator,
     typename = _RequireInputIter<_InputIterator>,
     typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator, _Allocator)
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> map<_Key, _Tp, less<_Key>, _Allocator>;
# 1569 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 1590 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<pair<const _Key, _Tp>>
    operator<=>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
  const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1643 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
  map<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::map<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::map<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class map;
# 101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::multimap must have the same value_type as its allocator");



    public:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class multimap<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };
#pragma GCC diagnostic pop

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;

      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;


      using node_type = typename _Rep_type::node_type;
# 190 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)) { }
# 212 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      multimap(const multimap&) = default;
# 221 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      multimap(multimap&&) = default;
# 233 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      multimap(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multimap(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      multimap(const multimap& __m,
        const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      multimap(multimap&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      multimap(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 277 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 293 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 326 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      ~multimap() = default;
# 342 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap&) = default;


      multimap&
      operator=(multimap&&) = default;
# 360 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 518 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 545 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...);
 }
# 567 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 606 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
 }
# 640 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 653 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }
# 679 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      iterator
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 749 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 786 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 807 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 890 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 914 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 932 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 951 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_t._M_find_tr(__x), void(), true)
 { return _M_t._M_find_tr(__x) != _M_t.end(); }
# 975 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1000 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1020 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1040 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1067 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1094 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const multimap<_K1, _T1, _C1, _A1>&,
     const multimap<_K1, _T1, _C1, _A1>&);


      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<pair<const _K1, _T1>>
 operator<=>(const multimap<_K1, _T1, _C1, _A1>&,
      const multimap<_K1, _T1, _C1, _A1>&);






  };



  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<_Key, _Tp, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator, _Allocator)
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
# 1192 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 1213 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<pair<const _Key, _Tp>>
    operator<=>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
  const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1266 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
  multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multimap<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/erase_if.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/erase_if.h" 3
namespace std
{


  namespace __detail
  {
    template<typename _Container, typename _UnsafeContainer,
      typename _Predicate>
      typename _Container::size_type
      __erase_nodes_if(_Container& __cont, _UnsafeContainer& __ucont,
         _Predicate __pred)
      {
 typename _Container::size_type __num = 0;
 for (auto __iter = __ucont.begin(), __last = __ucont.end();
      __iter != __last;)
   {
     if (__pred(*__iter))
       {
  __iter = __cont.erase(__iter);
  ++__num;
       }
     else
       ++__iter;
   }
 return __num;
      }
  }


}
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 2 3
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/map" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using map
 = std::map<_Key, _Tp, _Cmp,
     polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using multimap
 = std::multimap<_Key, _Tp, _Cmp,
   polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename map<_Key, _Tp, _Compare, _Alloc>::size_type
    erase_if(map<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::map<_Key, _Tp, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename multimap<_Key, _Tp, _Compare, _Alloc>::size_type
    erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::multimap<_Key, _Tp, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 20 "include/klm/bklm/geometry/GeometryPar.h" 2


namespace Belle2 {

  class GearDir;

  namespace bklm {






    class GeometryPar {

    public:


      static GeometryPar* instance(void);


      static GeometryPar* instance(const GearDir&);


      static GeometryPar* instance(const BKLMGeometryPar&);


      bool doBeamBackgroundStudy(void) const
      {
        return m_DoBeamBackgroundStudy;
      }


      double getLayerInnerRadius(int layer) const;


      double getLayerOuterRadius(int layer) const;


      const CLHEP::Hep3Vector getGapHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getModuleHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getModuleInteriorHalfSize1(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getModuleInteriorHalfSize2(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getElectrodeHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getGasHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getAirHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getScintEnvelopeHalfSize(int layer, bool hasChimney) const;


      const CLHEP::Hep3Vector getScintEnvelopeOffset(int layer, bool hasChimney) const;



      int getScintEnvelopeOffsetSign(int layer) const
      {
        return m_ScintEnvelopeOffsetSign[layer - 1];
      }


      double getPolystyreneOffsetX(void) const;


      double getScintTiO2ThicknessTop(void) const
      {
        return m_ScintTiO2ThicknessTop;
      }


      double getScintTiO2ThicknessSide(void) const
      {
        return m_ScintTiO2ThicknessSide;
      }


      double getScintHalfHeight(void) const
      {
        return 0.5 * m_ScintHeight;
      }


      double getScintHalfWidth(void) const
      {
        return 0.5 * m_ScintWidth;
      }


      double getScintBoreRadius(void) const
      {
        return m_ScintBoreRadius;
      }


      double getScintFiberRadius(void) const
      {
        return m_ScintFiberRadius;
      }


      double getGapMiddleRadius(int layer) const;


      double getModuleMiddleRadius(int layer) const;


      double getActiveMiddleRadius(int section, int sector, int layer) const;


      bool getModuleFlip(int section, int sector, int layer) const
      {
        return m_IsFlipped[section][sector - 1][layer - 1];
      }


      double getRotation(void) const
      {
        return m_Rotation;
      }


      double getOffsetZ(void) const
      {
        return m_OffsetZ;
      }


      double getPhi(void) const
      {
        return m_Phi;
      }


      double getSolenoidOuterRadius(void) const
      {
        return m_SolenoidOuterRadius;
      }


      int getNSector(void) const
      {
        return m_NSector;
      }


      double getHalfLength(void) const
      {
        return m_HalfLength;
      }


      double getOuterRadius(void) const
      {
        return m_OuterRadius;
      }


      int getNLayer(void) const
      {
        return m_NLayer;
      }


      double getIronNominalHeight(void) const
      {
        return m_IronNominalHeight;
      }


      double getIronActualHeight(void) const
      {
        return m_IronActualHeight;
      }


      double getGap1InnerRadius(void) const
      {
        return m_Gap1InnerRadius;
      }


      double getGap1NominalHeight(void) const
      {
        return m_Gap1NominalHeight;
      }


      double getGap1ActualHeight(void) const
      {
        return m_Gap1ActualHeight;
      }


      double getGap1IronWidth(void) const
      {
        return m_Gap1IronWidth;
      }


      double getGapLength(void) const
      {
        return m_GapLength;
      }


      double getGapNominalHeight(void) const
      {
        return m_GapNominalHeight;
      }


      double getGapActualHeight(void) const
      {
        return m_GapActualHeight;
      }


      double getGapIronWidth(void) const
      {
        return m_GapIronWidth;
      }


      double getGapInnerRadius(void) const
      {
        return m_GapInnerRadius;
      }


      int getNZStrips(bool isChimney) const
      {
        return (isChimney ? m_NZStripsChimney : m_NZStrips);
      }


      int getNPhiStrips(int layer) const;


      int getNZScints(bool isChimney) const
      {
        return (isChimney ? m_NZScintsChimney : m_NZScints);
      }


      int getNPhiScints(int layer) const;


      double getMaximalPhiStripLength() const
      {
        return m_MaximalPhiStripLength;
      }


      double getMaximalZStripLength() const
      {
        return m_MaximalZStripLength;
      }


      double getModuleLength(void) const
      {
        return m_ModuleLength;
      }


      double getModuleLengthChimney(void) const
      {
        return m_ModuleLengthChimney;
      }


      double getModuleCoverHeight(void) const
      {
        return m_ModuleCoverHeight;
      }


      double getModuleCopperHeight(void) const
      {
        return m_ModuleCopperHeight;
      }


      double getModuleFoamHeight(void) const
      {
        return m_ModuleFoamHeight;
      }


      double getModuleMylarHeight(void) const
      {
        return m_ModuleMylarHeight;
      }


      double getModuleGlassHeight(void) const
      {
        return m_ModuleGlassHeight;
      }


      double getModuleGasHeight(void) const
      {
        return m_ModuleGasHeight;
      }


      double getModuleHeight(void) const
      {
        return m_ModuleHeight;
      }


      double getModuleFrameWidth(void) const
      {
        return m_ModuleFrameWidth;
      }


      double getModuleFrameThickness(void) const
      {
        return m_ModuleFrameThickness;
      }


      double getModuleGasSpacerWidth(void) const
      {
        return m_ModuleGasSpacerWidth;
      }


      double getModuleElectrodeBorder(void) const
      {
        return m_ModuleElectrodeBorder;
      }


      const CLHEP::Hep3Vector getChimneyHalfSize(int layer) const;


      const CLHEP::Hep3Vector getChimneyPosition(int layer) const;


      double getChimneyCoverThickness(void) const
      {
        return m_ChimneyCoverThickness;
      }


      double getChimneyHousingInnerRadius(void) const
      {
        return m_ChimneyHousingInnerRadius;
      }


      double getChimneyHousingOuterRadius(void) const
      {
        return m_ChimneyHousingOuterRadius;
      }


      double getChimneyShieldInnerRadius(void) const
      {
        return m_ChimneyShieldInnerRadius;
      }


      double getChimneyShieldOuterRadius(void) const
      {
        return m_ChimneyShieldOuterRadius;
      }


      double getChimneyPipeInnerRadius(void) const
      {
        return m_ChimneyPipeInnerRadius;
      }


      double getChimneyPipeOuterRadius(void) const
      {
        return m_ChimneyPipeOuterRadius;
      }


      double getRibThickness(void) const
      {
        return m_RibThickness;
      }


      double getCablesWidth(void) const
      {
        return m_CablesWidth;
      }


      double getBraceWidth(void) const
      {
        return m_BraceWidth;
      }


      double getBraceWidthChimney(void) const
      {
        return m_BraceWidthChimney;
      }


      const CLHEP::Hep3Vector getSupportPlateHalfSize(bool) const;


      double getBracketWidth(void) const
      {
        return m_BracketWidth;
      }


      double getBracketThickness(void) const
      {
        return m_BracketThickness;
      }


      double getBracketLength(void) const
      {
        return m_BracketLength;
      }


      double getBracketRibWidth(void) const
      {
        return m_BracketRibWidth;
      }


      double getBracketRibThickness(void) const
      {
        return m_BracketRibThickness;
      }


      double getBracketInnerRadius(void) const
      {
        return m_BracketInnerRadius;
      }


      double getBracketZPosition(int, bool) const;


      double getBracketCutoutDphi(void) const
      {
        return m_BracketCutoutDphi;
      }


      int getNReadoutStation(void) const
      {
        return m_NReadoutStation;
      }


      bool getReadoutStationIsPhi(int station) const
      {
        return m_ReadoutStationIsPhi[station - 1];
      }


      double getReadoutStationPosition(int station) const
      {
        return m_ReadoutStationPosition[station - 1];
      }


      const CLHEP::Hep3Vector getReadoutContainerHalfSize(void) const;


      const CLHEP::Hep3Vector getReadoutCarrierHalfSize(void) const;


      const CLHEP::Hep3Vector getReadoutPreamplifierHalfSize(void) const;


      int getNReadoutPreamplifierPosition(void) const
      {
        return m_ReadoutPreamplifierPosition.size();
      }


      double getReadoutPreamplifierPosition(int preamp) const
      {
        return m_ReadoutPreamplifierPosition[preamp - 1];
      }


      const CLHEP::Hep3Vector getReadoutConnectorsHalfSize(void) const;


      double getReadoutConnectorsPosition(void) const
      {
        return m_ReadoutConnectorsPosition;
      }


      double getMPPCHousingRadius(void) const
      {
        return m_MPPCHousingRadius;
      }


      double getMPPCHousingHalfLength(void) const
      {
        return 0.5 * m_MPPCHousingLength;
      }


      double getMPPCHalfLength(void) const
      {
        return 0.5 * m_MPPCLength;
      }


      double getMPPCHalfWidth(void) const
      {
        return 0.5 * m_MPPCWidth;
      }


      double getMPPCHalfHeight(void) const
      {
        return 0.5 * m_MPPCHeight;
      }


      bool hasRPCs(int layer) const;


      const Module* findModule(int section, int sector, int layer) const;


      const HepGeom::Transform3D getModuleAlignment(int section, int sector, int layer) const;


      const HepGeom::Transform3D getModuleDisplacedGeo(int section, int sector, int layer) const;






      double getBKLMLayerArea(int section, int sector, int layer) const;

    private:


      explicit GeometryPar(const GearDir&);


      explicit GeometryPar(const Belle2::BKLMGeometryPar&);


      GeometryPar(GeometryPar&);


      GeometryPar& operator=(const GeometryPar&);


      ~GeometryPar();


      void clear();


      void read(const GearDir&);


      void readFromDB(const BKLMGeometryPar&);


      void calculate();




      void readAlignmentFromDB();



      void readDisplacedGeoFromDB();





      HepGeom::Transform3D getTransformFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta, double dGamma);


      bool m_DoBeamBackgroundStudy;


      double m_Rotation;


      double m_SectorRotation[2][BKLMElementNumbers::getMaximalSectorNumber()];


      double m_OffsetZ;


      double m_Phi;


      int m_NSector;


      double m_SolenoidOuterRadius;


      double m_OuterRadius;


      double m_HalfLength;


      int m_NLayer;


      double m_IronNominalHeight;


      double m_IronActualHeight;


      double m_Gap1InnerRadius;


      double m_Gap1NominalHeight;


      double m_Gap1ActualHeight;


      double m_Layer1Height;


      double m_LayerHeight;


      double m_Gap1IronWidth;


      double m_GapLength;


      double m_GapNominalHeight;


      double m_GapActualHeight;


      double m_GapIronWidth;


      double m_GapInnerRadius;


      int m_NPhiStrips[BKLMElementNumbers::getMaximalLayerNumber()];


      int m_NPhiScints[BKLMElementNumbers::getMaximalLayerNumber()];


      int m_NZStrips;


      int m_NZStripsChimney;


      int m_NZScints;


      int m_NZScintsChimney;



      int m_ScintEnvelopeOffsetSign[BKLMElementNumbers::getMaximalLayerNumber()];


      double m_PhiStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];


      double m_ZStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];


      double m_ZScintDLength[BKLMElementNumbers::getMaximalLayerNumber()][NZSCINT];


      double m_MaximalPhiStripLength = 0;


      double m_MaximalZStripLength = 0;


      double m_ModuleLength;


      double m_ModuleLengthChimney;


      double m_ModuleCoverHeight;


      double m_ModuleCopperHeight;


      double m_ModuleFoamHeight;


      double m_ModuleMylarHeight;


      double m_ModuleReadoutHeight;


      double m_ModuleGlassHeight;


      double m_ModuleGasHeight;


      double m_ModuleHeight;


      double m_ModuleFrameWidth;


      double m_ModuleFrameThickness;


      double m_ModuleGasSpacerWidth;


      double m_ModuleElectrodeBorder;


      double m_ModulePolystyreneInnerHeight;


      double m_ModulePolystyreneOuterHeight;


      double m_ScintWidth;


      double m_ScintHeight;


      double m_ScintBoreRadius;


      double m_ScintFiberRadius;


      double m_ScintTiO2ThicknessTop;


      double m_ScintTiO2ThicknessSide;


      double m_ChimneyLength;


      double m_ChimneyWidth;


      double m_ChimneyCoverThickness;


      double m_ChimneyHousingInnerRadius;


      double m_ChimneyHousingOuterRadius;


      double m_ChimneyShieldInnerRadius;


      double m_ChimneyShieldOuterRadius;


      double m_ChimneyPipeInnerRadius;


      double m_ChimneyPipeOuterRadius;


      double m_RibThickness;


      double m_CablesWidth;


      double m_BraceWidth;


      double m_BraceWidthChimney;


      double m_SupportPlateWidth;


      double m_SupportPlateHeight;


      double m_SupportPlateLength;


      double m_SupportPlateLengthChimney;


      double m_BracketWidth;


      double m_BracketThickness;


      double m_BracketLength;


      double m_BracketRibWidth;


      double m_BracketRibThickness;


      double m_BracketInset;


      double m_BracketInnerRadius;


      double m_BracketCutoutDphi;


      int m_NReadoutStation;


      bool m_ReadoutStationIsPhi[NSTATION];


      double m_ReadoutStationPosition[NSTATION];


      double m_ReadoutContainerLength;


      double m_ReadoutContainerWidth;


      double m_ReadoutContainerHeight;


      double m_ReadoutCarrierLength;


      double m_ReadoutCarrierWidth;


      double m_ReadoutCarrierHeight;


      double m_ReadoutPreamplifierLength;


      double m_ReadoutPreamplifierWidth;


      double m_ReadoutPreamplifierHeight;


      std::vector<double> m_ReadoutPreamplifierPosition;


      double m_ReadoutConnectorsLength;


      double m_ReadoutConnectorsWidth;


      double m_ReadoutConnectorsHeight;


      double m_ReadoutConnectorsPosition;


      double m_MPPCHousingRadius;


      double m_MPPCHousingLength;


      double m_MPPCLength;


      double m_MPPCWidth;


      double m_MPPCHeight;


      bool m_HasRPCs[BKLMElementNumbers::getMaximalLayerNumber()];


      double m_LocalReconstructionShiftX[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


      double m_LocalReconstructionShiftY[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


      double m_LocalReconstructionShiftZ[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


      bool m_IsFlipped[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];


      std::map<int, Module*> m_Modules;


      std::map<int, HepGeom::Transform3D> m_Alignments;


      std::map<int, HepGeom::Transform3D> m_Displacements;


      static GeometryPar* m_Instance;

    };

  }

}
# 11 "klm/bklm/geometry/src/GeometryPar.cc" 2



# 1 "include/klm/dataobjects/KLMChannelIndex.h" 1
# 12 "include/klm/dataobjects/KLMChannelIndex.h"
# 1 "include/klm/dataobjects/KLMElementNumbers.h" 1
# 13 "include/klm/dataobjects/KLMElementNumbers.h"
# 1 "include/klm/dataobjects/eklm/EKLMElementNumbers.h" 1
# 14 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
namespace Belle2 {





  class EKLMElementNumbers : public TObject {

  public:




    enum Section {


      c_BackwardSection = 1,


      c_ForwardSection = 2,

    };




    static const EKLMElementNumbers& Instance();







    bool checkSection(int section, bool fatalError = true) const;







    bool checkLayer(int layer, bool fatalError = true) const;
# 66 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    bool checkDetectorLayer(int section, int layer,
                            bool fatalError = true) const;







    bool checkSector(int sector, bool fatalError = true) const;







    bool checkPlane(int plane, bool fatalError = true) const;







    bool checkSegment(int segment, bool fatalError = true) const;







    bool checkStrip(int strip, bool fatalError = true) const;
# 109 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int detectorLayerNumber(int section, int layer) const;







    void layerNumberToElementNumbers(
      int layerGlobal, int* section, int* layer) const;
# 129 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int sectorNumber(int section, int layer, int sector) const;
# 139 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int sectorNumberKLMOrder(int section, int sector) const;
# 148 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    void sectorNumberToElementNumbers(
      int sectorGlobal, int* section, int* layer, int* sector) const;
# 161 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int planeNumber(int section, int layer, int sector, int plane) const;
# 171 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    void planeNumberToElementNumbers(
      int planeGlobal, int* section, int* layer, int* sector, int* plane)
    const;
# 186 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int segmentNumber(int section, int layer, int sector, int plane,
                      int segment) const;
# 198 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    void segmentNumberToElementNumbers(
      int segmentGlobal, int* section, int* layer, int* sector, int* plane,
      int* segment) const;
# 213 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    int stripNumber(int section, int layer, int sector, int plane,
                    int strip) const;
# 225 "include/klm/dataobjects/eklm/EKLMElementNumbers.h"
    void stripNumberToElementNumbers(
      int stripGlobal, int* section, int* layer, int* sector, int* plane,
      int* strip) const;





    int getSectionByGlobalStrip(int stripGlobal);





    int getLayerByGlobalStrip(int stripGlobal);





    int getSectorByGlobalStrip(int stripGlobal);





    int getPlaneByGlobalStrip(int stripGlobal);





    int getStripByGlobalStrip(int stripGlobal);






    static std::string getHSLBName(int copper, int slot);




    static constexpr int getMaximalSectionNumber()
    {
      return m_MaximalSectionNumber;
    }




    static constexpr int getMaximalLayerNumber()
    {
      return m_MaximalLayerNumber;
    }





    int getMaximalDetectorLayerNumber(int section) const;




    static constexpr int getMaximalSectorNumber()
    {
      return m_MaximalSectorNumber;
    }




    static constexpr int getMaximalPlaneNumber()
    {
      return m_MaximalPlaneNumber;
    }




    static constexpr int getMaximalSegmentNumber()
    {
      return m_MaximalSegmentNumber;
    }




    static constexpr int getMaximalStripNumber()
    {
      return m_MaximalStripNumber;
    }




    static constexpr int getMaximalLayerGlobalNumber()
    {
      return m_MaximalDetectorLayerNumber[0] + m_MaximalDetectorLayerNumber[1];
    }




    static constexpr int getMaximalSectorGlobalNumber()
    {
      return m_MaximalSectorNumber * getMaximalLayerGlobalNumber();
    }




    static constexpr int getMaximalSectorGlobalNumberKLMOrder()
    {
      return m_MaximalSectionNumber * m_MaximalSectorNumber;
    }




    static constexpr int getMaximalPlaneGlobalNumber()
    {
      return m_MaximalPlaneNumber * getMaximalSectorGlobalNumber();
    }




    static constexpr int getMaximalSegmentGlobalNumber()
    {
      return m_MaximalSegmentNumber * getMaximalPlaneGlobalNumber();
    }




    static constexpr int getMaximalStripGlobalNumber()
    {
      return m_MaximalStripNumber * getMaximalPlaneGlobalNumber();
    }




    static constexpr int getNStripsLayer()
    {
      return getNStripsSector() * m_MaximalSectorNumber;
    }




    static constexpr int getNStripsSector()
    {
      return m_MaximalPlaneNumber * m_MaximalStripNumber;
    }




    static constexpr int getNStripsSegment()
    {
      return m_NStripsSegment;
    }




    static constexpr int getTotalChannelNumber()
    {
      return m_TotalChannelNumber;
    }

  private:




    EKLMElementNumbers();




    ~EKLMElementNumbers();

  protected:


    static constexpr int m_MaximalSectionNumber = 2;


    static constexpr int m_MaximalLayerNumber = 14;


    static constexpr int m_MaximalDetectorLayerNumber[2] = {12, 14};


    static constexpr int m_MaximalSectorNumber = 4;


    static constexpr int m_MaximalPlaneNumber = 2;


    static constexpr int m_MaximalSegmentNumber = 5;


    static constexpr int m_MaximalStripNumber = 75;


    static constexpr int m_NStripsSegment = 15;


    static constexpr int m_TotalChannelNumber = 15600;

  private:


    private: static_assert(std::is_integral<decltype(3)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("EKLMElementNumbers") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 3; } virtual TClass *IsA() const { return EKLMElementNumbers::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(EKLMElementNumbers::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { EKLMElementNumbers::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/klm/dataobjects/eklm/EKLMElementNumbers.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 444; };

  };

}
# 14 "include/klm/dataobjects/KLMElementNumbers.h" 2





namespace Belle2 {




  class KLMElementNumbers {

  public:




    enum Subdetector {


      c_BKLM = 1,


      c_EKLM = 2,

    };




    static const KLMElementNumbers& Instance();
# 55 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMChannelNumber channelNumber(int subdetector, int section, int sector, int layer,
                                   int plane, int strip) const;
# 66 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMChannelNumber channelNumberBKLM(int section, int sector, int layer, int plane,
                                       int strip) const;





    KLMChannelNumber channelNumberBKLM(int bklmChannel) const;
# 83 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMChannelNumber channelNumberEKLM(int section, int sector, int layer, int plane,
                                       int strip) const;





    KLMChannelNumber channelNumberEKLM(int eklmStrip) const;






    bool isBKLMChannel(KLMChannelNumber channel) const;






    bool isEKLMChannel(KLMChannelNumber channel) const;






    int localChannelNumberBKLM(KLMChannelNumber channel) const;






    int localChannelNumberEKLM(KLMChannelNumber channel) const;
# 130 "include/klm/dataobjects/KLMElementNumbers.h"
    void channelNumberToElementNumbers(
      KLMChannelNumber channel, int* subdetector, int* section, int* sector,
      int* layer, int* plane, int* strip) const;
# 142 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMPlaneNumber planeNumber(int subdetector, int section, int sector,
                               int layer, int plane) const;
# 152 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMPlaneNumber planeNumberBKLM(int section, int sector, int layer,
                                   int plane) const;
# 162 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMPlaneNumber planeNumberEKLM(int section, int sector, int layer,
                                   int plane) const;
# 172 "include/klm/dataobjects/KLMElementNumbers.h"
    KLMModuleNumber moduleNumber(int subdetector, int section, int sector,
                                 int layer) const;







    KLMModuleNumber moduleNumberBKLM(int section, int sector, int layer) const;







    KLMModuleNumber moduleNumberEKLM(int section, int sector, int layer) const;





    KLMModuleNumber moduleNumberByChannel(KLMChannelNumber channel) const;
# 205 "include/klm/dataobjects/KLMElementNumbers.h"
    void moduleNumberToElementNumbers(
      KLMModuleNumber module, int* subdetector, int* section, int* sector,
      int* layer) const;





    unsigned int getNChannelsModule(KLMModuleNumber module) const;






    KLMSectorNumber sectorNumberBKLM(int section, int sector) const;






    KLMSectorNumber sectorNumberEKLM(int section, int sector) const;







    int getExtrapolationLayer(int subdetector, int layer) const;




    static constexpr int getMaximalExtrapolationLayer()
    {
      return EKLMElementNumbers::getMaximalLayerNumber() +
             BKLMElementNumbers::getMaximalLayerNumber();
    }




    static constexpr int getTotalModuleNumber()
    {
      return EKLMElementNumbers::getMaximalSectorGlobalNumber() +
             BKLMElementNumbers::getMaximalLayerGlobalNumber();
    }





    int getMinimalPlaneNumber(int subdetector) const;




    static constexpr int getMaximalPlaneNumber()
    {

      return std::max(EKLMElementNumbers::getMaximalPlaneNumber(),
                      BKLMElementNumbers::getMaximalPlaneNumber() + 1);
    }







    std::string getSectorDAQName(int subdetector, int section, int sector) const;




    static constexpr int getTotalChannelNumber()
    {
      return BKLMElementNumbers::getTotalChannelNumber() +
             EKLMElementNumbers::getTotalChannelNumber();
    }

  private:




    KLMElementNumbers();




    ~KLMElementNumbers();


    static constexpr uint16_t m_BKLMOffset = 0x8000;


    const EKLMElementNumbers* m_eklmElementNumbers;

  };

}
# 13 "include/klm/dataobjects/KLMChannelIndex.h" 2

namespace Belle2 {




  class KLMChannelIndex {

  public:




    enum IndexLevel {


      c_IndexLevelSubdetector = 1,


      c_IndexLevelSection = 2,


      c_IndexLevelSector = 3,


      c_IndexLevelLayer = 4,


      c_IndexLevelPlane = 5,


      c_IndexLevelStrip = 6,

    };





    explicit KLMChannelIndex(enum IndexLevel indexLevel = c_IndexLevelStrip);
# 64 "include/klm/dataobjects/KLMChannelIndex.h"
    KLMChannelIndex(int subdetector, int section, int sector,
                    int layer, int plane, int strip,
                    enum IndexLevel indexLevel = c_IndexLevelStrip);




    ~KLMChannelIndex();





    void setIndexLevel(enum IndexLevel indexLevel);







    void useEKLMSegments(bool useSegments = true);





    void setKLMModule(KLMModuleNumber module);





    void setEKLMSegment(int segment);




    int getSubdetector() const
    {
      return m_Subdetector;
    }




    int getSection() const
    {
      return m_Section;
    }




    int getSector() const
    {
      return m_Sector;
    }




    int getLayer() const
    {
      return m_Layer;
    }




    int getPlane() const
    {
      return m_Plane;
    }




    int getStrip() const
    {
      return m_Strip;
    }




    KLMChannelNumber getKLMChannelNumber() const;




    KLMPlaneNumber getKLMPlaneNumber() const;




    KLMModuleNumber getKLMModuleNumber() const;




    KLMSectorNumber getKLMSectorNumber() const;




    int getEKLMSegmentNumber() const;




    KLMChannelIndex beginBKLM();




    KLMChannelIndex& endBKLM();




    KLMChannelIndex beginEKLM();




    KLMChannelIndex& endEKLM();




    KLMChannelIndex begin()
    {
      return beginBKLM();
    }




    KLMChannelIndex& end()
    {
      return endEKLM();
    }




    KLMChannelIndex& operator++();




    KLMChannelIndex& increment();




    bool operator==(const KLMChannelIndex& index) const;




    bool operator!=(const KLMChannelIndex& index) const;




    KLMChannelIndex& operator*();

  protected:




    void setNStripsPlane();




    void increment(enum IndexLevel indexLevel);


    enum IndexLevel m_IndexLevel;


    int m_Subdetector;


    int m_Section;


    int m_Sector;


    int m_Layer;


    int m_Plane;


    int m_Strip;


    bool m_UseEKLMSegments = false;


    int m_NStripsPlane;


    const KLMElementNumbers* m_ElementNumbers;


    const EKLMElementNumbers* m_eklmElementNumbers;

  };

}
# 15 "klm/bklm/geometry/src/GeometryPar.cc" 2
# 1 "include/klm/dbobjects/bklm/BKLMAlignment.h" 1
# 13 "include/klm/dbobjects/bklm/BKLMAlignment.h"
# 1 "include/klm/dbobjects/KLMAlignmentData.h" 1
# 14 "include/klm/dbobjects/KLMAlignmentData.h"
namespace Belle2 {




  class KLMAlignmentData : public TObject {

  public:




    enum ParameterNumbers {


      c_DeltaU = 1,


      c_DeltaV = 2,


      c_DeltaW = 3,


      c_DeltaAlpha = 4,


      c_DeltaBeta = 5,


      c_DeltaGamma = 6,

    };




    KLMAlignmentData();
# 62 "include/klm/dbobjects/KLMAlignmentData.h"
    KLMAlignmentData(float deltaU, float deltaV, float deltaW,
                     float deltaAlpha, float deltaBeta, float deltaGamma);




    ~KLMAlignmentData();




    float getDeltaU() const
    {
      return m_DeltaU;
    }





    void setDeltaU(float deltaU)
    {
      m_DeltaU = deltaU;
    }




    float getDeltaV() const
    {
      return m_DeltaV;
    }





    void setDeltaV(float deltaV)
    {
      m_DeltaV = deltaV;
    }




    float getDeltaW() const
    {
      return m_DeltaW;
    }





    void setDeltaW(float deltaW)
    {
      m_DeltaW = deltaW;
    }




    float getDeltaAlpha() const
    {
      return m_DeltaAlpha;
    }





    void setDeltaAlpha(float deltaAlpha)
    {
      m_DeltaAlpha = deltaAlpha;
    }




    float getDeltaBeta() const
    {
      return m_DeltaBeta;
    }





    void setDeltaBeta(float deltaBeta)
    {
      m_DeltaBeta = deltaBeta;
    }




    float getDeltaGamma() const
    {
      return m_DeltaGamma;
    }





    void setDeltaGamma(float deltaGamma)
    {
      m_DeltaGamma = deltaGamma;
    }





    float getParameter(enum ParameterNumbers number) const;






    void setParameter(enum ParameterNumbers number, float value);

  private:


    float m_DeltaU;


    float m_DeltaV;


    float m_DeltaW;


    float m_DeltaAlpha;


    float m_DeltaBeta;


    float m_DeltaGamma;


    private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("Belle2::KLMAlignmentData") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return Belle2::KLMAlignmentData::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(Belle2::KLMAlignmentData::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { Belle2::KLMAlignmentData::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/klm/dbobjects/KLMAlignmentData.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 206; };

  };

}
# 14 "include/klm/dbobjects/bklm/BKLMAlignment.h" 2







namespace Belle2 {




  class BKLMAlignment : public TObject {

  public:




    BKLMAlignment();




    ~BKLMAlignment();






    void setModuleAlignment(KLMModuleNumber module, KLMAlignmentData* dat);





    const KLMAlignmentData* getModuleAlignment(KLMModuleNumber module) const;







    static unsigned short getGlobalUniqueID()
    {
      return 30;
    }







    double getGlobalParam(unsigned short element, unsigned short param) const;







    void setGlobalParam(double value, unsigned short element,
                        unsigned short param);



    std::vector<std::pair<unsigned short, unsigned short>> listGlobalParams();

  private:


    std::map<KLMModuleNumber, KLMAlignmentData> m_ModuleAlignment;


    private: static_assert(std::is_integral<decltype(3)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("Belle2::BKLMAlignment") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 3; } virtual TClass *IsA() const { return Belle2::BKLMAlignment::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(Belle2::BKLMAlignment::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { Belle2::BKLMAlignment::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/klm/dbobjects/bklm/BKLMAlignment.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 91; };

  };

}
# 16 "klm/bklm/geometry/src/GeometryPar.cc" 2


# 1 "include/framework/gearbox/GearDir.h" 1
# 11 "include/framework/gearbox/GearDir.h"
# 1 "include/framework/gearbox/Interface.h" 1
# 11 "include/framework/gearbox/Interface.h"
# 1 "include/framework/core/FrameworkExceptions.h" 1
# 10 "include/framework/core/FrameworkExceptions.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/workaround.hpp" 1 3







# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/workaround.hpp" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/workaround.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/user.hpp" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/select_compiler_config.hpp" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/compiler/clang.hpp" 1 3
# 370 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/compiler/clang.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/compiler/clang_version.hpp" 1 3
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/compiler/clang.hpp" 2 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/select_stdlib_config.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/select_stdlib_config.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/version" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/version" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/version" 2 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/select_stdlib_config.hpp" 2 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/stdlib/libstdcpp3.hpp" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/select_platform_config.hpp" 1 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/platform/linux.hpp" 1 3
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/platform/linux.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/posix_features.hpp" 1 3
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/platform/linux.hpp" 2 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 3
# 510 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 3
namespace boost{

   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;




}



namespace boost{

   __extension__ typedef __int128 int128_type;
   __extension__ typedef unsigned __int128 uint128_type;




}
# 572 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/helper_macros.hpp" 1 3
# 573 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 2 3
# 1322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/cxx_composite.hpp" 1 3
# 1323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/detail/suffix.hpp" 2 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config.hpp" 2 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/workaround.hpp" 2 3
# 9 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/workaround.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/locale" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/locale" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ctime" 1 3
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 208 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const throw ();

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }


      void
      _M_am_pm_format(const _CharT*) const
      { }


      void
      _M_am_pm_format(const _CharT** __ampm_format) const
      {
 __ampm_format[0] = _M_data->_M_am_pm_format;
      }

      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = 0);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const throw ();



}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/time_members.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }


}
# 355 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __time_get_state
  {

    void
    _M_finalize_state(tm* __tm);

    unsigned int _M_have_I : 1;
    unsigned int _M_have_wday : 1;
    unsigned int _M_have_yday : 1;
    unsigned int _M_have_mon : 1;
    unsigned int _M_have_mday : 1;
    unsigned int _M_have_uweek : 1;
    unsigned int _M_have_wweek : 1;
    unsigned int _M_have_century : 1;
    unsigned int _M_is_pm : 1;
    unsigned int _M_want_century : 1;
    unsigned int _M_want_xday : 1;
    unsigned int _M_pad1 : 5;
    unsigned int _M_week_no : 6;
    unsigned int _M_pad2 : 10;
    int _M_century;
    int _M_pad3;
  };

namespace __cxx11 {
# 399 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 420 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 461 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 486 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 514 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 543 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 569 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 590 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 617 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 637 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 655 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 674 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 693 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 712 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 731 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 754 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual

      iter_type
      do_get(iter_type __s, iter_type __end, ios_base& __f,
             ios_base::iostate& __err, tm* __tm,
             char __format, char __modifier) const;



      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
          const _CharT** __names, size_t __indexlen,
          ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format) const;



      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format,
       __time_get_state &__state) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;


  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }


      explicit
      time_get_byname(const string& __s, size_t __refs = 0)
      : time_get_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~time_get_byname() { }
    };

}
# 836 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 857 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 876 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()
      { }
# 923 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
    };
# 968 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 {
# 1063 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1092 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(); }
# 1105 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 1120 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1134 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1147 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1177 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1190 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1207 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1224 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1240 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
# 1298 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1310 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1336 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1349 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1376 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1390 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1404 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 {
# 1507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1529 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1559 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1590 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 1614 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1626 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1646 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1668 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1689 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1709 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1732 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 1767 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1791 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1811 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 {
# 1854 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1882 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1909 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1927 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1945 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1956 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1976 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1995 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/messages_members.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/messages_members.h" 3
# 1 "/usr/include/libintl.h" 1 3 4
# 34 "/usr/include/libintl.h" 3 4
extern "C" {




extern char *gettext (const char *__msgid)
     noexcept (true) __attribute__ ((__format_arg__ (1)));



extern char *dgettext (const char *__domainname, const char *__msgid)
     noexcept (true) __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (const char *__domainname, const char *__msgid)
     noexcept (true) __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (const char *__domainname,
   const char *__msgid, int __category)
     noexcept (true) __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (const char *__domainname,
     const char *__msgid, int __category)
     noexcept (true) __attribute__ ((__format_arg__ (2)));




extern char *ngettext (const char *__msgid1, const char *__msgid2,
         unsigned long int __n)
     noexcept (true) __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (const char *__domainname, const char *__msgid1,
   const char *__msgid2, unsigned long int __n)
     noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (const char *__domainname, const char *__msgid1,
    const char *__msgid2, unsigned long int __n,
    int __category)
     noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (const char *__domainname) noexcept (true);



extern char *bindtextdomain (const char *__domainname,
        const char *__dirname) noexcept (true);



extern char *bind_textdomain_codeset (const char *__domainname,
          const char *__codeset) noexcept (true);
# 121 "/usr/include/libintl.h" 3 4
}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;



}
# 2067 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/codecvt.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/codecvt.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{



  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 162 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 203 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 244 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 281 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/codecvt.h" 3
   template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
 _M_c_locale_codecvt(0)
      { }

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
      friend class messages<char>;

    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };






  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
      friend class messages<wchar_t>;

    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };







  template<>
    class codecvt<char16_t, char, mbstate_t>
    : public __codecvt_abstract_base<char16_t, char, mbstate_t>
    {
    public:

      typedef char16_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<>
    class codecvt<char32_t, char, mbstate_t>
    : public __codecvt_abstract_base<char32_t, char, mbstate_t>
    {
    public:

      typedef char32_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };






  template<>
    class codecvt<char16_t, char8_t, mbstate_t>
    : public __codecvt_abstract_base<char16_t, char8_t, mbstate_t>
    {
    public:

      typedef char16_t intern_type;
      typedef char8_t extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char16_t, char8_t, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<>
    class codecvt<char32_t, char8_t, mbstate_t>
    : public __codecvt_abstract_base<char32_t, char8_t, mbstate_t>
    {
    public:

      typedef char32_t intern_type;
      typedef char8_t extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char32_t, char8_t, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }


      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~codecvt_byname() { }
    };


  template<>
    class codecvt_byname<char16_t, char, mbstate_t>
    : public codecvt<char16_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char16_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };

  template<>
    class codecvt_byname<char32_t, char, mbstate_t>
    : public codecvt<char32_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char32_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };


  template<>
    class codecvt_byname<char16_t, char8_t, mbstate_t>
    : public codecvt<char16_t, char8_t, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char16_t, char8_t, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };

  template<>
    class codecvt_byname<char32_t, char8_t, mbstate_t>
    : public codecvt<char32_t, char8_t, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char32_t, char8_t, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };







  extern template class codecvt_byname<char, char, mbstate_t>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);


  extern template class codecvt_byname<wchar_t, char, mbstate_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);



  extern template class codecvt_byname<char16_t, char, mbstate_t>;
  extern template class codecvt_byname<char32_t, char, mbstate_t>;


  extern template class codecvt_byname<char16_t, char8_t, mbstate_t>;
  extern template class codecvt_byname<char32_t, char8_t, mbstate_t>;







}

#pragma GCC diagnostic pop
# 2070 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.tcc" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      struct _Scoped_str
      {
 size_t _M_len;
 _CharT* _M_str;

 explicit
 _Scoped_str(const basic_string<_CharT>& __str)
 : _M_len(__str.size()), _M_str(new _CharT[_M_len])
 { __str.copy(_M_str, _M_len); }

 ~_Scoped_str() { delete[] _M_str; }

 void
 _M_release(const _CharT*& __p, size_t& __n)
 {
   __p = _M_str;
   __n = _M_len;
   _M_str = 0;
 }
      };

      _Scoped_str __curr_symbol(__mp.curr_symbol());
      _Scoped_str __positive_sign(__mp.positive_sign());
      _Scoped_str __negative_sign(__mp.negative_sign());

      const string& __g = __mp.grouping();
      const size_t __g_size = __g.size();
      char* const __grouping = new char[__g_size];
      __g.copy(__grouping, __g_size);



      _M_grouping = __grouping;
      _M_grouping_size = __g_size;
      _M_use_grouping = (__g_size
    && static_cast<signed char>(__grouping[0]) > 0
    && (__grouping[0]
        != __gnu_cxx::__numeric_traits<char>::__max));

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();

      __curr_symbol._M_release(_M_curr_symbol, _M_curr_symbol_size);
      __positive_sign._M_release(_M_positive_sign, _M_positive_sign_size);
      __negative_sign._M_release(_M_negative_sign, _M_negative_sign_size);

      _M_frac_digits = __mp.frac_digits();
      _M_pos_format = __mp.pos_format();
      _M_neg_format = __mp.neg_format();

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(money_base::_S_atoms,
   money_base::_S_atoms + money_base::_S_end, _M_atoms);

      _M_allocated = true;
    }

namespace __cxx11 {

  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || (__mandatory_sign
      && (static_cast<part>(__p.field[3])
          == money_base::sign)))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, (void)++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   if (__lc->_M_frac_digits <= 0)
     break;

   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;

       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, (void)++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 370 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 422 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     long __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
       {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
  if (__lc->_M_grouping_size)
    {
      __value.assign(2 * __paddec, char_type());
      _CharT* __vend =
        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.erase(__vend - &__value[0]);
    }
  else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
       }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 592 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
 }
# 624 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 682 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.tcc" 3
}




  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format,
     __time_get_state &__state) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      ios_base::iostate __tmperr = ios_base::goodbit;
      size_t __i = 0;
      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':
  case 'A':

    const char_type* __days[14];
    __tp._M_days(&__days[0]);
    __tp._M_days_abbreviated(&__days[7]);
    __beg = _M_extract_name(__beg, __end, __mem, __days,
       14, __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_wday = __mem % 7;
        __state._M_have_wday = 1;
      }
    break;
  case 'h':
  case 'b':
  case 'B':

    const char_type* __months[24];
    __tp._M_months(&__months[0]);
    __tp._M_months_abbreviated(&__months[12]);
    __beg = _M_extract_name(__beg, __end, __mem,
       __months, 24, __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mon = __mem % 12;
        __state._M_have_mon = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dt[0], __state);
    if (!__tmperr)
      __state._M_want_xday = 1;
    break;
  case 'C':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 99, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_century = __mem;
        __state._M_have_century = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'd':
  case 'e':

    if (__ctype.is(ctype_base::space, *__beg))
      ++__beg;
    __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mday = __mem;
        __state._M_have_mday = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    if (!__tmperr)
      __state._M_want_xday = 1;
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_hour = __mem;
        __state._M_have_I = 0;
      }
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_hour = __mem % 12;
        __state._M_have_I = 1;
      }
    break;
  case 'j':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 366, 3,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_yday = __mem - 1;
        __state._M_have_yday = 1;
      }
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mon = __mem - 1;
        __state._M_have_mon = 1;
      }
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_min = __mem;
    break;
  case 'n':
  case 't':
    while (__beg != __end
    && __ctype.is(ctype_base::space, *__beg))
      ++__beg;
    break;
  case 'p':

    const char_type* __ampm[2];
    __tp._M_am_pm(&__ampm[0]);
    if (!__ampm[0][0] || !__ampm[1][0])
      break;
    __beg = _M_extract_name(__beg, __end, __mem, __ampm,
       2, __io, __tmperr);
    if (!__tmperr && __mem)
      __state._M_is_pm = 1;
    break;
  case 'r':

    const char_type* __ampm_format;
    __tp._M_am_pm_format(&__ampm_format);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __ampm_format, __state);
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,



      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_sec = __mem;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    break;
  case 'U':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 53, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_week_no = __mem;
        __state._M_have_uweek = 1;
      }
    break;
  case 'w':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 6, 1,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_wday = __mem;
        __state._M_have_wday = 1;
      }
    break;
  case 'W':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 53, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_week_no = __mem;
        __state._M_have_wweek = 1;
      }
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dates[0], __state);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __times[0], __state);
    break;
  case 'y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 99, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_want_century = 1;
        __state._M_want_xday = 1;


        __c = 0;
        if (__beg != __end)
   __c = __ctype.narrow(*__beg, '*');
        if (__c >= '0' && __c <= '9')
   {
     ++__beg;
     __mem = __mem * 10 + (__c - '0');
     if (__beg != __end)
       {
         __c = __ctype.narrow(*__beg, '*');
         if (__c >= '0' && __c <= '9')
    {
      ++__beg;
      __mem = __mem * 10 + (__c - '0');
    }
       }
     __mem -= 1900;
     __state._M_want_century = 0;
   }


        else if (__mem < 69)
   __mem += 100;
        __tm->tm_year = __mem;
      }
    break;
  case 'Y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_year = __mem - 1900;
        __state._M_want_century = 0;
        __state._M_want_xday = 1;
      }
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __tmperr);


        if (__beg != __end && !__tmperr && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __tmperr);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __tmperr);
   }
      }
    else
      __tmperr |= ios_base::failbit;
    break;
  case '%':
    if (*__beg == __ctype.widen('%'))
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  default:

    __tmperr |= ios_base::failbit;
  }
     }
   else if (__ctype.is(ctype_base::space, __format[__i]))
     {

       while (__beg != __end
       && __ctype.is(ctype_base::space, *__beg))
  ++__beg;
     }
   else
     {


       if (__ctype.tolower(__format[__i]) == __ctype.tolower(*__beg)
    || __ctype.toupper(__format[__i]) == __ctype.toupper(*__beg))
  ++__beg;
       else
  __tmperr |= ios_base::failbit;
     }
 }

      if (__tmperr || __i != __len)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      __time_get_state __state = __time_get_state();
      return _M_extract_via_format(__beg, __end, __io, __err, __tm,
       __format, __state);
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       if (__value > __max)
  break;
     }
   else
     break;
 }
      if (__i && __value >= __min && __value <= __max)
 __member = __value;
      else
 __err |= ios_base::failbit;

      return __beg;
    }






  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t* __matches
 = static_cast<size_t*>(__builtin_alloca(2 * sizeof(size_t)
      * __indexlen));
      size_t* __lengths = __matches + __indexlen;
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;
      bool __begupdated = false;


      if (__beg != __end)
 {
   const char_type __c = *__beg;

   const char_type __cl = __ctype.tolower(__c);
   const char_type __cu = __ctype.toupper(__c);
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__cl == __ctype.tolower(__names[__i1][0])
  || __cu == __ctype.toupper(__names[__i1][0]))
       {
  __lengths[__nmatches]
    = __traits_type::length(__names[__i1]);
  __matches[__nmatches++] = __i1;
       }
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __lengths[0];
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen, __lengths[__i2]);
   ++__pos;
   ++__beg;
   if (__pos == __minlen)
     {






       bool __match_longer = false;

       if (__beg != __end)
  {

    const char_type __cl = __ctype.tolower(*__beg);
    const char_type __cu = __ctype.toupper(*__beg);
    for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
      {
        __name = __names[__matches[__i3]];
        if (__lengths[__i3] > __pos
     && (__ctype.tolower(__name[__pos]) == __cl
         || __ctype.toupper(__name[__pos]) == __cu))
   {
     __match_longer = true;
     break;
   }
      }
  }
       for (size_t __i4 = 0; __i4 < __nmatches;)
  if (__match_longer == (__lengths[__i4] == __pos))
    {
      __matches[__i4] = __matches[--__nmatches];
      __lengths[__i4] = __lengths[__nmatches];
    }
  else
    ++__i4;
       if (__match_longer)
  {
    __minlen = __lengths[0];
    for (size_t __i5 = 1; __i5 < __nmatches; ++__i5)
      __minlen = std::min(__minlen, __lengths[__i5]);
  }
       else
  {


    if (__nmatches == 2 && (__indexlen & 1) == 0)
      {
        if (__matches[0] < __indexlen / 2)
   {
     if (__matches[1] == __matches[0] + __indexlen / 2)
       __nmatches = 1;
   }
        else if (__matches[1] == __matches[0] - __indexlen / 2)
   {
     __matches[0] = __matches[1];
     __lengths[0] = __lengths[1];
     __nmatches = 1;
   }
      }
    __begupdated = true;
    break;
  }
     }
   if (__pos < __minlen && __beg != __end)
     {

       const char_type __cl = __ctype.tolower(*__beg);
       const char_type __cu = __ctype.toupper(*__beg);
       for (size_t __i6 = 0; __i6 < __nmatches;)
  {
    __name = __names[__matches[__i6]];
    if (__ctype.tolower(__name[__pos]) != __cl
        && __ctype.toupper(__name[__pos]) != __cu)
      {
        __matches[__i6] = __matches[--__nmatches];
        __lengths[__i6] = __lengths[__nmatches];
      }
    else
      ++__i6;
  }
     }
   else
     break;
 }

      if (__nmatches == 1)
 {

   if (!__begupdated)
     {
       ++__beg;
       ++__pos;
     }
   __name = __names[__matches[0]];
   const size_t __len = __lengths[0];
   while (__pos < __len
   && __beg != __end

   && (__ctype.tolower(__name[__pos]) == __ctype.tolower(*__beg)
       || (__ctype.toupper(__name[__pos])
    == __ctype.toupper(*__beg))))
     ++__beg, (void)++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t* __matches_lengths = 0;
      size_t __pos = 0;

      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
     if (__c == __names[__i][0]
  || __c == __ctype.toupper(__names[__i][0]))
       __matches[__nmatches++] = __i;
 }

      if (__nmatches)
 {
   ++__beg;
   ++__pos;

   __matches_lengths
     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
          * __nmatches));
   for (size_t __i = 0; __i < __nmatches; ++__i)
     __matches_lengths[__i]
       = __traits_type::length(__names[__matches[__i]]);
 }

      for (; __beg != __end; ++__beg, (void)++__pos)
 {
   size_t __nskipped = 0;
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < __nmatches;)
     {
       const char_type* __name = __names[__matches[__i]];
       if (__pos >= __matches_lengths[__i])
  ++__nskipped, ++__i;
       else if (!(__name[__pos] == __c))
  {
    --__nmatches;
    __matches[__i] = __matches[__nmatches];
    __matches_lengths[__i] = __matches_lengths[__nmatches];
  }
       else
  ++__i;
     }
   if (__nskipped == __nmatches)
     break;
 }

      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
   || (__nmatches == 2 && (__matches_lengths[0] == __pos
      || __matches_lengths[1] == __pos)))
 __member = (__matches[0] >= (int)__indexlen
      ? __matches[0] - (int)__indexlen : __matches[0]);
      else
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0], __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0], __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __days[14];
      __tp._M_days_abbreviated(__days);
      __tp._M_days(__days + 7);
      int __tmpwday;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_wday = __tmpwday;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __months[24];
      __tp._M_months_abbreviated(__months);
      __tp._M_months(__months + 12);
      int __tmpmon;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_mon = __tmpmon;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      int __tmpyear;
      ios_base::iostate __tmperr = ios_base::goodbit;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 99, 2,
        __io, __tmperr);
      if (!__tmperr)
 {
   char __c = 0;
   if (__beg != __end)
     __c = __ctype.narrow(*__beg, '*');



   if (__c >= '0' && __c <= '9')
     {
       ++__beg;
       __tmpyear = __tmpyear * 10 + (__c - '0');
       if (__beg != __end)
  {
    __c = __ctype.narrow(*__beg, '*');
    if (__c >= '0' && __c <= '9')
      {
        ++__beg;
        __tmpyear = __tmpyear * 10 + (__c - '0');
      }
  }
       __tmpyear -= 1900;
     }
   else if (__tmpyear < 69)
     __tmpyear += 100;
   __tm->tm_year = __tmpyear;
 }
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    get(iter_type __s, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
        const char_type* __fmtend) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;
      bool __use_state = false;
# 1489 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.tcc" 3
      __time_get_state __state = __time_get_state();
      while (__fmt != __fmtend &&
             __err == ios_base::goodbit)
        {
          if (__s == __end)
            {
              __err = ios_base::eofbit | ios_base::failbit;
              break;
            }
          else if (__ctype.narrow(*__fmt, 0) == '%')
            {
       const char_type* __fmt_start = __fmt;
              char __format;
              char __mod = 0;
              if (++__fmt == __fmtend)
                {
                  __err = ios_base::failbit;
                  break;
                }
              const char __c = __ctype.narrow(*__fmt, 0);
              if (__c != 'E' && __c != 'O')
                __format = __c;
              else if (++__fmt != __fmtend)
                {
                  __mod = __c;
                  __format = __ctype.narrow(*__fmt, 0);
                }
              else
                {
                  __err = ios_base::failbit;
                  break;
                }
       if (__use_state)
  {
    char_type __new_fmt[4];
    __new_fmt[0] = __fmt_start[0];
    __new_fmt[1] = __fmt_start[1];
    if (__mod)
      {
        __new_fmt[2] = __fmt_start[2];
        __new_fmt[3] = char_type();
      }
    else
      __new_fmt[2] = char_type();
    __s = _M_extract_via_format(__s, __end, __io, __err, __tm,
           __new_fmt, __state);
    if (__s == __end)
      __err |= ios_base::eofbit;
  }
       else
  __s = this->do_get(__s, __end, __io, __err, __tm, __format,
       __mod);
              ++__fmt;
            }
          else if (__ctype.is(ctype_base::space, *__fmt))
            {
              ++__fmt;
              while (__fmt != __fmtend &&
                     __ctype.is(ctype_base::space, *__fmt))
                ++__fmt;

              while (__s != __end &&
                     __ctype.is(ctype_base::space, *__s))
                ++__s;
            }

          else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
                   __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
            {
              ++__s;
              ++__fmt;
            }
          else
            {
              __err = ios_base::failbit;
              break;
            }
        }
      if (__use_state)
 __state._M_finalize_state(__tm);
      return __s;
    }

  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, tm* __tm,
           char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;

      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
        {
          __fmt[1] = __format;
          __fmt[2] = char_type();
        }
      else
        {
          __fmt[1] = __mod;
          __fmt[2] = __format;
          __fmt[3] = char_type();
        }

      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt,
        __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type __res[__maxlen];






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"
#pragma GCC diagnostic ignored "-Wlong-long"
  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class __cxx11:: money_get<char>;
  extern template class __cxx11:: money_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;

  extern template
    const moneypunct<char, true>*
    __try_use_facet<moneypunct<char, true> >(const locale&) noexcept;

  extern template
    const moneypunct<char, false>*
    __try_use_facet<moneypunct<char, false> >(const locale&) noexcept;

  extern template
    const money_put<char>*
    __try_use_facet<money_put<char> >(const locale&) noexcept;

  extern template
    const money_get<char>*
    __try_use_facet<money_get<char> >(const locale&) noexcept;

  extern template
    const __timepunct<char>*
    __try_use_facet<__timepunct<char> >(const locale&) noexcept;

  extern template
    const time_put<char>*
    __try_use_facet<time_put<char> >(const locale&) noexcept;

  extern template
    const time_get<char>*
    __try_use_facet<time_get<char> >(const locale&) noexcept;

  extern template
    const messages<char>*
    __try_use_facet<messages<char> >(const locale&) noexcept;

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class __cxx11:: money_get<wchar_t>;
  extern template class __cxx11:: money_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;

  extern template
    const moneypunct<wchar_t, true>*
    __try_use_facet<moneypunct<wchar_t, true> >(const locale&) noexcept;

  extern template
    const moneypunct<wchar_t, false>*
    __try_use_facet<moneypunct<wchar_t, false> >(const locale&) noexcept;

  extern template
    const money_put<wchar_t>*
    __try_use_facet<money_put<wchar_t> >(const locale&) noexcept;

  extern template
    const money_get<wchar_t>*
    __try_use_facet<money_get<wchar_t> >(const locale&) noexcept;

  extern template
    const __timepunct<wchar_t>*
    __try_use_facet<__timepunct<wchar_t> >(const locale&) noexcept;

  extern template
    const time_put<wchar_t>*
    __try_use_facet<time_put<wchar_t> >(const locale&) noexcept;

  extern template
    const time_get<wchar_t>*
    __try_use_facet<time_get<wchar_t> >(const locale&) noexcept;

  extern template
    const messages<wchar_t>*
    __try_use_facet<messages<wchar_t> >(const locale&) noexcept;

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);

#pragma GCC diagnostic pop



}
# 2072 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_facets_nonio.h" 2 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/locale" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_conv.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_conv.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _OutStr, typename _InChar, typename _Codecvt,
    typename _State, typename _Fn>
    bool
    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
       _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
       size_t& __count, _Fn __fn)
    {
      if (__first == __last)
 {
   __outstr.clear();
   __count = 0;
   return true;
 }

      size_t __outchars = 0;
      auto __next = __first;
      const auto __maxlen = __cvt.max_length() + 1;

      codecvt_base::result __result;
      do
 {
   __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
   auto __outnext = &__outstr.front() + __outchars;
   auto const __outlast = &__outstr.back() + 1;
   __result = (__cvt.*__fn)(__state, __next, __last, __next,
     __outnext, __outlast, __outnext);
   __outchars = __outnext - &__outstr.front();
 }
      while (__result == codecvt_base::partial && __next != __last
      && ptrdiff_t(__outstr.size() - __outchars) < __maxlen);

      if (__result == codecvt_base::error)
 {
   __count = __next - __first;
   return false;
 }



      if constexpr (is_same<typename _Codecvt::intern_type,
           typename _Codecvt::extern_type>())
 if (__result == codecvt_base::noconv)
   {
     __outstr.assign(__first, __last);
     __count = __last - __first;
     return true;
   }

      __outstr.resize(__outchars);
      __count = __next - __first;
      return true;
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt,
       _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const char*, const char*, const char*&,
   _CharT*, _CharT*, _CharT*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in_all(const char* __first, const char* __last,
    basic_string<_CharT, _Traits, _Alloc>& __outstr,
    const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == size_t(__last - __first));
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt,
        _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
   char*, char*, char*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
     basic_string<char, _Traits, _Alloc>& __outstr,
     const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == size_t(__last - __first));
    }




  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char8_t, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char8_t, _State>& __cvt,
        _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char8_t, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
   char8_t*, char8_t*, char8_t*&) const;
      _ConvFn __fn = &codecvt<_CharT, char8_t, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }

  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char8_t, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char8_t, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }



  namespace __detail
  {
    template<typename _Tp>
      struct _Scoped_ptr
      {
 __attribute__((__nonnull__(2)))
 explicit
 _Scoped_ptr(_Tp* __ptr) noexcept
 : _M_ptr(__ptr)
 { }

 _Scoped_ptr(_Tp* __ptr, const char* __msg)
 : _M_ptr(__ptr)
 {
   if (!__ptr)
     __throw_logic_error(__msg);
 }

 ~_Scoped_ptr() { delete _M_ptr; }

 _Scoped_ptr(const _Scoped_ptr&) = delete;
 _Scoped_ptr& operator=(const _Scoped_ptr&) = delete;

 __attribute__((__returns_nonnull__))
 _Tp* operator->() const noexcept { return _M_ptr; }

 _Tp& operator*() const noexcept { return *_M_ptr; }

      private:
 _Tp* _M_ptr;
      };
  }

namespace __cxx11 {


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Wide_alloc = allocator<_Elem>,
    typename _Byte_alloc = allocator<char>>
    class [[__deprecated__]] wstring_convert
    {
    public:
      typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
      typedef typename _Codecvt::state_type state_type;
      typedef typename wide_string::traits_type::int_type int_type;


      wstring_convert() : _M_cvt(new _Codecvt()) { }







      explicit
      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt, "wstring_convert")
      { }
# 291 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/locale_conv.h" 3
      wstring_convert(_Codecvt* __pcvt, state_type __state)
      : _M_cvt(__pcvt, "std::wstring_convert"),
 _M_state(__state), _M_with_cvtstate(true)
      { }






      explicit
      wstring_convert(const byte_string& __byte_err,
        const wide_string& __wide_err = wide_string())
      : _M_cvt(new _Codecvt),
 _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
 _M_with_strings(true)
      { }

      ~wstring_convert() = default;



      wstring_convert(const wstring_convert&) = delete;
      wstring_convert& operator=(const wstring_convert&) = delete;


      wide_string
      from_bytes(char __byte)
      {
 char __bytes[2] = { __byte };
 return from_bytes(__bytes, __bytes+1);
      }

      wide_string
      from_bytes(const char* __ptr)
      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }

      wide_string
      from_bytes(const byte_string& __str)
      {
 auto __ptr = __str.data();
 return from_bytes(__ptr, __ptr + __str.size());
      }

      wide_string
      from_bytes(const char* __first, const char* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 wide_string __out{ _M_wide_err_string.get_allocator() };
 if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
        _M_count))
   return __out;
 if (_M_with_strings)
   return _M_wide_err_string;
 __throw_range_error("wstring_convert::from_bytes");
      }



      byte_string
      to_bytes(_Elem __wchar)
      {
 _Elem __wchars[2] = { __wchar };
 return to_bytes(__wchars, __wchars+1);
      }

      byte_string
      to_bytes(const _Elem* __ptr)
      {
 return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
      }

      byte_string
      to_bytes(const wide_string& __wstr)
      {
 auto __ptr = __wstr.data();
 return to_bytes(__ptr, __ptr + __wstr.size());
      }

      byte_string
      to_bytes(const _Elem* __first, const _Elem* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 byte_string __out{ _M_byte_err_string.get_allocator() };
 if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
         _M_count))
   return __out;
 if (_M_with_strings)
   return _M_byte_err_string;
 __throw_range_error("wstring_convert::to_bytes");
      }





      size_t converted() const noexcept { return _M_count; }


      state_type state() const { return _M_state; }

    private:
      __detail::_Scoped_ptr<_Codecvt> _M_cvt;
      byte_string _M_byte_err_string;
      wide_string _M_wide_err_string;
      state_type _M_state = state_type();
      size_t _M_count = 0;
      bool _M_with_cvtstate = false;
      bool _M_with_strings = false;
    };

}


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Tr = char_traits<_Elem>>
    class [[__deprecated__]] 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) { }
# 428 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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, "std::wbuffer_convert"),
 _M_state(__state), _M_always_noconv(_M_cvt->always_noconv())
      {
 if (_M_buf)
   {
     this->setp(_M_put_area, _M_put_area + _S_buffer_length);
     this->setg(_M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length);
   }
      }

      ~wbuffer_convert() = default;



      wbuffer_convert(const wbuffer_convert&) = delete;
      wbuffer_convert& operator=(const wbuffer_convert&) = delete;

      streambuf* rdbuf() const noexcept { return _M_buf; }

      streambuf*
      rdbuf(streambuf *__bytebuf) noexcept
      {
 auto __prev = _M_buf;
 _M_buf = __bytebuf;
 return __prev;
      }


      state_type state() const noexcept { return _M_state; }

    protected:
      int
      sync()
      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }

      typename _Wide_streambuf::int_type
      overflow(typename _Wide_streambuf::int_type __out)
      {
 if (!_M_buf || !_M_conv_put())
   return _Tr::eof();
 else if (!_Tr::eq_int_type(__out, _Tr::eof()))
   return this->sputc(__out);
 return _Tr::not_eof(__out);
      }

      typename _Wide_streambuf::int_type
      underflow()
      {
 if (!_M_buf)
   return _Tr::eof();

 if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
   return _Tr::to_int_type(*this->gptr());
 else
   return _Tr::eof();
      }

      streamsize
      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
      {
 if (!_M_buf || __n == 0)
   return 0;
 streamsize __done = 0;
 do
 {
   auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
        __n - __done);
   _Tr::copy(this->pptr(), __s + __done, __nn);
   this->pbump(__nn);
   __done += __nn;
 } while (__done < __n && _M_conv_put());
 return __done;
      }

    private:

      bool
      _M_conv_get()
      {
 const streamsize __pb1 = this->gptr() - this->eback();
 const streamsize __pb2 = _S_putback_length;
 const streamsize __npb = std::min(__pb1, __pb2);

 _Tr::move(_M_get_area + _S_putback_length - __npb,
    this->gptr() - __npb, __npb);

 streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
 __nbytes = std::min(__nbytes, _M_buf->in_avail());
 if (__nbytes < 1)
   __nbytes = 1;
 __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
 if (__nbytes < 1)
   return false;
 __nbytes += _M_unconv;



 _Elem* __outbuf = _M_get_area + _S_putback_length;
 _Elem* __outnext = __outbuf;
 const char* __bnext = _M_get_buf;

 codecvt_base::result __result;
 if (_M_always_noconv)
   __result = codecvt_base::noconv;
 else
   {
     _Elem* __outend = _M_get_area + _S_buffer_length;

     __result = _M_cvt->in(_M_state,
      __bnext, __bnext + __nbytes, __bnext,
      __outbuf, __outend, __outnext);
   }

 if (__result == codecvt_base::noconv)
   {

     auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
     _Tr::copy(__outbuf, __get_buf, __nbytes);
     _M_unconv = 0;
     return true;
   }

 if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
   char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);

 this->setg(__outbuf, __outbuf, __outnext);

 return __result != codecvt_base::error;
      }


      bool
      _M_put(...)
      { return false; }

      bool
      _M_put(const char* __p, streamsize __n)
      {
 if (_M_buf->sputn(__p, __n) < __n)
   return false;
 return true;
      }


      bool
      _M_conv_put()
      {
 _Elem* const __first = this->pbase();
 const _Elem* const __last = this->pptr();
 const streamsize __pending = __last - __first;

 if (_M_always_noconv)
   return _M_put(__first, __pending);

 char __outbuf[2 * _S_buffer_length];

 const _Elem* __next = __first;
 const _Elem* __start;
 do
   {
     __start = __next;
     char* __outnext = __outbuf;
     char* const __outlast = __outbuf + sizeof(__outbuf);
     auto __result = _M_cvt->out(_M_state, __next, __last, __next,
     __outnext, __outlast, __outnext);
     if (__result == codecvt_base::error)
       return false;
     else if (__result == codecvt_base::noconv)
       return _M_put(__next, __pending);

     if (!_M_put(__outbuf, __outnext - __outbuf))
       return false;
   }
 while (__next != __last && __next != __start);

 if (__next != __last)
   _Tr::move(__first, __next, __last - __next);

 this->pbump(__first - __next);
 return __next != __first;
      }

      streambuf* _M_buf;
      __detail::_Scoped_ptr<_Codecvt> _M_cvt;
      state_type _M_state;

      static const streamsize _S_buffer_length = 32;
      static const streamsize _S_putback_length = 3;
      _Elem _M_put_area[_S_buffer_length];
      _Elem _M_get_area[_S_buffer_length];
      streamsize _M_unconv = 0;
      char _M_get_buf[_S_buffer_length-_S_putback_length];
      bool _M_always_noconv;
    };




}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/locale" 2 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/compat_workarounds.hpp" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/compat_workarounds.hpp" 3
namespace boost {
    namespace io {



        template<class Tr>
        class CompatTraits;




        template<class Alloc>
        class CompatAlloc;
    }
}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/config_macros.hpp" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/config_macros.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/workarounds_gcc-2_95.hpp" 1 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/config_macros.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/workarounds_stlport.hpp" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/config_macros.hpp" 2 3
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/config_macros.hpp" 3
namespace boost { namespace io { namespace detail {

    typedef ::std:: locale locale_t;



} } }
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/compat_workarounds.hpp" 2 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/compat_workarounds.hpp" 3
namespace boost {
    namespace io {


        template<class Tr>
        class CompatTraits
        {
        public:
            typedef Tr compatible_type;
        };


        template<class Alloc>
        class CompatAlloc
        {
        public:
            typedef Alloc compatible_type;
        };

    }
}
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_fwd.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_fwd.hpp" 3
namespace boost {

    template <class Ch,
        class Tr = ::std:: char_traits<Ch>, class Alloc = std::allocator<Ch> >
    class basic_format;

    typedef basic_format<char > format;


    typedef basic_format<wchar_t > wformat;


    namespace io {
        enum format_error_bits { bad_format_string_bit = 1,
                                 too_few_args_bit = 2, too_many_args_bit = 4,
                                 out_of_range_bit = 8,
                                 all_error_bits = 255, no_error_bits=0 };

    }

}
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals_fwd.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals_fwd.hpp" 3
namespace boost {
namespace io {

namespace detail {
  template<class Ch, class Tr> struct stream_format_state;
    template<class Ch, class Tr, class Alloc> struct format_item;





    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    modify_item_body (basic_format<Ch, Tr, Alloc>& self,
                      int itemN, T manipulator);

    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    bind_arg_body (basic_format<Ch, Tr, Alloc>& self,
                   int argN, const T& val);


    template<class Ch, class Tr, class T>
    void apply_manip_body (stream_format_state<Ch, Tr>& self,
                           T manipulator);


    template<class Ch, class Tr, class Alloc, class T>
    void distribute (basic_format<Ch,Tr, Alloc>& self, T x);

    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    feed (basic_format<Ch,Tr, Alloc>& self, T x);

    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    feed_impl (basic_format<Ch,Tr, Alloc>& self, T x);

}

}
}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/ignore_unused.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/ignore_unused.hpp" 3
namespace boost {





template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused(Ts&& ...)
{}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/ignore_unused.hpp" 3
template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused()
{}
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/ignore_unused.hpp" 3
}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/addressof.hpp" 1 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/addressof.hpp" 3
namespace boost {

template<class T>
constexpr inline T*
addressof(T& o) noexcept
{
    return __builtin_addressof(o);
}

}
# 266 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/addressof.hpp" 3
namespace boost {

template<class T>
const T* addressof(const T&&) = delete;

}
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/enable_if.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/enable_if.hpp" 3
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> {};

}
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/invoke_swap.hpp" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/invoke_swap.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 1 3
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 1 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace rel_ops __attribute__ ((__deprecated__ ("use '" "<=>" "' instead")))
  {
# 86 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 99 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 125 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }
  }


}
# 71 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 2 3
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{




  template <typename _Tp, typename _Up = _Tp>
    constexpr
    inline _Tp
    exchange(_Tp& __obj, _Up&& __new_val)
    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
      is_nothrow_assignable<_Tp&, _Up>>::value)
    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }



  template<typename _Tp>
    [[nodiscard]]
    constexpr add_const_t<_Tp>&
    as_const(_Tp& __t) noexcept
    { return __t; }

  template<typename _Tp>
    void as_const(const _Tp&&) = delete;



  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_equal(_Tp __t, _Up __u) noexcept
    {
      static_assert(__is_standard_integer<_Tp>::value);
      static_assert(__is_standard_integer<_Up>::value);

      if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
 return __t == __u;
      else if constexpr (is_signed_v<_Tp>)
 return __t >= 0 && make_unsigned_t<_Tp>(__t) == __u;
      else
 return __u >= 0 && __t == make_unsigned_t<_Up>(__u);
    }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_not_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_equal(__t, __u); }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_less(_Tp __t, _Up __u) noexcept
    {
      static_assert(__is_standard_integer<_Tp>::value);
      static_assert(__is_standard_integer<_Up>::value);

      if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
 return __t < __u;
      else if constexpr (is_signed_v<_Tp>)
 return __t < 0 || make_unsigned_t<_Tp>(__t) < __u;
      else
 return __u >= 0 && __t < make_unsigned_t<_Up>(__u);
    }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_greater(_Tp __t, _Up __u) noexcept
    { return std::cmp_less(__u, __t); }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_less_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_less(__u, __t); }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_greater_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_less(__t, __u); }

  template<typename _Res, typename _Tp>
    constexpr bool
    in_range(_Tp __t) noexcept
    {
      static_assert(__is_standard_integer<_Res>::value);
      static_assert(__is_standard_integer<_Tp>::value);
      using __gnu_cxx::__int_traits;

      if constexpr (is_signed_v<_Tp> == is_signed_v<_Res>)
 return __int_traits<_Res>::__min <= __t
   && __t <= __int_traits<_Res>::__max;
      else if constexpr (is_signed_v<_Tp>)
 return __t >= 0
   && make_unsigned_t<_Tp>(__t) <= __int_traits<_Res>::__max;
      else
 return __t <= make_unsigned_t<_Res>(__int_traits<_Res>::__max);
    }
# 238 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/utility" 3
}
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/invoke_swap.hpp" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/invoke_swap.hpp" 3
namespace boost_swap_impl {



template<class T> struct is_const { enum _vt { value = 0 }; };
template<class T> struct is_const<T const> { enum _vt { value = 1 }; };




using namespace std;

template<class T>

inline void invoke_swap_impl(T& left, T& right) noexcept((noexcept((swap(left, right)))))
{
    swap(left, right);
}

template<class T, std::size_t N>

inline void invoke_swap_impl(T (& left)[N], T (& right)[N])
    noexcept((noexcept((::boost_swap_impl::invoke_swap_impl(left[0], right[0])))))
{
    for (std::size_t i = 0; i < N; ++i)
    {
        ::boost_swap_impl::invoke_swap_impl(left[i], right[i]);
    }
}

}

namespace boost {
namespace core {

template<class T>

inline typename enable_if_c< !::boost_swap_impl::is_const<T>::value >::type
invoke_swap(T& left, T& right)
    noexcept((noexcept((::boost_swap_impl::invoke_swap_impl(left, right)))))
{
    ::boost_swap_impl::invoke_swap_impl(left, right);
}

}
}
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/launder.hpp" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/launder.hpp" 3
namespace boost
{
namespace core
{



template<class T> T* launder( T* p )
{
    return __builtin_launder( p );
}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/launder.hpp" 3
}
}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/bad_optional_access.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/bad_optional_access.hpp" 3
namespace boost {


#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"


class bad_optional_access : public std::logic_error
{
public:
  bad_optional_access()
    : std::logic_error("Attempted to access the value of an uninitialized optional object.")
    {}
};


#pragma clang diagnostic pop


}
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/exception/exception.hpp" 1 3








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 1 3
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/cstdint.hpp" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/cstdint.hpp" 3
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/cstdint.hpp" 3
namespace boost {
    using ::intptr_t;
    using ::uintptr_t;
}
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 2 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/source_location" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/source_location" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/source_location" 2 3




namespace std
{



  struct source_location
  {
  private:
    using uint_least32_t = unsigned int;
    struct __impl
    {
      const char* _M_file_name;
      const char* _M_function_name;
      unsigned _M_line;
      unsigned _M_column;
    };
    using __builtin_ret_type = decltype(__builtin_source_location());

  public:


    static consteval source_location
    current(__builtin_ret_type __p = __builtin_source_location()) noexcept
    {
      source_location __ret;
      __ret._M_impl = static_cast <const __impl*>(__p);
      return __ret;
    }

    constexpr source_location() noexcept { }


    constexpr uint_least32_t
    line() const noexcept
    { return _M_impl ? _M_impl->_M_line : 0u; }

    constexpr uint_least32_t
    column() const noexcept
    { return _M_impl ? _M_impl->_M_column : 0u; }

    constexpr const char*
    file_name() const noexcept
    { return _M_impl ? _M_impl->_M_file_name : ""; }

    constexpr const char*
    function_name() const noexcept
    { return _M_impl ? _M_impl->_M_function_name : ""; }

  private:
    const __impl* _M_impl = nullptr;
  };


}
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 2 3


namespace boost
{

struct source_location
{
private:

    char const * file_;
    char const * function_;
    boost::uint_least32_t line_;
    boost::uint_least32_t column_;

public:

    constexpr source_location() noexcept: file_( "" ), function_( "" ), line_( 0 ), column_( 0 )
    {
    }

    constexpr source_location( char const * file, boost::uint_least32_t ln, char const * function, boost::uint_least32_t col = 0 ) noexcept: file_( file ), function_( function ), line_( ln ), column_( col )
    {
    }



    constexpr source_location( std::source_location const& loc ) noexcept: file_( loc.file_name() ), function_( loc.function_name() ), line_( loc.line() ), column_( loc.column() )
    {
    }



    constexpr char const * file_name() const noexcept
    {
        return file_;
    }

    constexpr char const * function_name() const noexcept
    {
        return function_;
    }

    constexpr boost::uint_least32_t line() const noexcept
    {
        return line_;
    }

    constexpr boost::uint_least32_t column() const noexcept
    {
        return column_;
    }
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert/source_location.hpp" 3
    std::string to_string() const
    {
        unsigned long ln = line();

        if( ln == 0 )
        {
            return "(unknown source location)";
        }

        std::string r = file_name();

        char buffer[ 16 ];

        std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), ":%lu", ln);
        r += buffer;

        unsigned long co = column();

        if( co )
        {
            std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), ":%lu", co);
            r += buffer;
        }

        char const* fn = function_name();

        if( *fn != 0 )
        {
            r += " in function '";
            r += fn;
            r += '\'';
        }

        return r;
    }







    inline friend bool operator==( source_location const& s1, source_location const& s2 ) noexcept
    {
        return std::strcmp( s1.file_, s2.file_ ) == 0 && std::strcmp( s1.function_, s2.function_ ) == 0 && s1.line_ == s2.line_ && s1.column_ == s2.column_;
    }

    inline friend bool operator!=( source_location const& s1, source_location const& s2 ) noexcept
    {
        return !( s1 == s2 );
    }
};



template<class E, class T> std::basic_ostream<E, T> & operator<<( std::basic_ostream<E, T> & os, source_location const & loc )
{
    os << loc.to_string();
    return os;
}



}
# 10 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/exception/exception.hpp" 2 3







namespace boost { template <class T> class shared_ptr; }
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/exception/exception.hpp" 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/exception/exception.hpp" 3







namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        class
        refcount_ptr
            {
            public:

            refcount_ptr():
                px_(0)
                {
                }

            ~refcount_ptr()
                {
                release();
                }

            refcount_ptr( refcount_ptr const & x ):
                px_(x.px_)
                {
                add_ref();
                }

            refcount_ptr &
            operator=( refcount_ptr const & x )
                {
                adopt(x.px_);
                return *this;
                }

            void
            adopt( T * px )
                {
                release();
                px_=px;
                add_ref();
                }

            T *
            get() const
                {
                return px_;
                }

            private:

            T * px_;

            void
            add_ref()
                {
                if( px_ )
                    px_->add_ref();
                }

            void
            release()
                {
                if( px_ && px_->release() )
                    px_=0;
                }
            };
        }



    template <class Tag,class T>
    class error_info;

    typedef error_info<struct throw_function_,char const *> throw_function;
    typedef error_info<struct throw_file_,char const *> throw_file;
    typedef error_info<struct throw_line_,int> throw_line;
    typedef error_info<struct throw_column_,int> throw_column;

    template <>
    class
    error_info<throw_function_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_file_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_line_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_column_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    class
    __attribute__((__visibility__("default")))
    exception;

    namespace
    exception_detail
        {
        class error_info_base;
        struct type_info_;

        struct
        error_info_container
            {
            virtual char const * diagnostic_information( char const * ) const = 0;
            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
            virtual void add_ref() const = 0;
            virtual bool release() const = 0;
            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;

            protected:

            ~error_info_container() noexcept
                {
                }
            };

        template <class>
        struct get_info;

        template <>
        struct get_info<throw_function>;

        template <>
        struct get_info<throw_file>;

        template <>
        struct get_info<throw_line>;

        template <>
        struct get_info<throw_column>;

        template <class>
        struct set_info_rv;

        template <>
        struct set_info_rv<throw_function>;

        template <>
        struct set_info_rv<throw_file>;

        template <>
        struct set_info_rv<throw_line>;

        template <>
        struct set_info_rv<throw_column>;

        char const * get_diagnostic_information( exception const &, char const * );

        void copy_boost_exception( exception *, exception const * );

        template <class E,class Tag,class T>
        E const & set_info( E const &, error_info<Tag,T> const & );

        template <class E>
        E const & set_info( E const &, throw_function const & );

        template <class E>
        E const & set_info( E const &, throw_file const & );

        template <class E>
        E const & set_info( E const &, throw_line const & );

        template <class E>
        E const & set_info( E const &, throw_column const & );

        boost::source_location get_exception_throw_location( exception const & );
        }

    class
    __attribute__((__visibility__("default")))
    exception
        {

        public:
        template <class Tag> void set( typename Tag::type const & );
        template <class Tag> typename Tag::type const * get() const;


        protected:

        exception():
            throw_function_(0),
            throw_file_(0),
            throw_line_(-1),
            throw_column_(-1)
            {
            }
# 281 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/exception/exception.hpp" 3
        virtual ~exception() noexcept

            = 0

            ;




        private:

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_function const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_file const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_line const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_column const & );

        template <class E,class Tag,class T>
        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );

        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );

        friend boost::source_location exception_detail::get_exception_throw_location( exception const & );

        template <class>
        friend struct exception_detail::get_info;
        friend struct exception_detail::get_info<throw_function>;
        friend struct exception_detail::get_info<throw_file>;
        friend struct exception_detail::get_info<throw_line>;
        friend struct exception_detail::get_info<throw_column>;
        template <class>
        friend struct exception_detail::set_info_rv;
        friend struct exception_detail::set_info_rv<throw_function>;
        friend struct exception_detail::set_info_rv<throw_file>;
        friend struct exception_detail::set_info_rv<throw_line>;
        friend struct exception_detail::set_info_rv<throw_column>;
        friend void exception_detail::copy_boost_exception( exception *, exception const * );

        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
        mutable char const * throw_function_;
        mutable char const * throw_file_;
        mutable int throw_line_;
        mutable int throw_column_;
        };

    inline
    exception::
    ~exception() noexcept
        {
        }

    namespace
    exception_detail
        {
        template <class E>
        E const &
        set_info( E const & x, throw_function const & y )
            {
            x.throw_function_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_file const & y )
            {
            x.throw_file_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_line const & y )
            {
            x.throw_line_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_column const & y )
            {
            x.throw_column_=y.v_;
            return x;
            }



        template <>
        struct
        set_info_rv<throw_column>
            {
            template <class E>
            static
            E const &
            set( E const & x, throw_column && y )
                {
                x.throw_column_=y.v_;
                return x;
                }
            };



        inline boost::source_location get_exception_throw_location( exception const & x )
            {
            return boost::source_location(
                x.throw_file_? x.throw_file_: "",
                x.throw_line_ >= 0? x.throw_line_: 0,
                x.throw_function_? x.throw_function_: "",
                x.throw_column_ >= 0? x.throw_column_: 0
                );
            }
        }



    namespace
    exception_detail
        {
        template <class T>
        struct
        __attribute__((__visibility__("default")))
        error_info_injector:
            public T,
            public exception
            {
            explicit
            error_info_injector( T const & x ):
                T(x)
                {
                }

            ~error_info_injector() noexcept
                {
                }
            };

        struct large_size { char c[256]; };
        large_size dispatch_boost_exception( exception const * );

        struct small_size { };
        small_size dispatch_boost_exception( void const * );

        template <class,int>
        struct enable_error_info_helper;

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(large_size)>
            {
            typedef T type;
            };

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(small_size)>
            {
            typedef error_info_injector<T> type;
            };

        template <class T>
        struct
        enable_error_info_return_type
            {
            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
            };
        }

    template <class T>
    inline
    typename
    exception_detail::enable_error_info_return_type<T>::type
    enable_error_info( T const & x )
        {
        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
        return rt(x);
        }






    namespace
    exception_detail
        {
        class
        __attribute__((__visibility__("default")))
        clone_base
            {
            public:

            virtual clone_base const * clone() const = 0;
            virtual void rethrow() const = 0;

            virtual
            ~clone_base() noexcept
                {
                }
            };

        inline
        void
        copy_boost_exception( exception * a, exception const * b )
            {
            refcount_ptr<error_info_container> data;
            if( error_info_container * d=b->data_.get() )
                data = d->clone();
            a->throw_file_ = b->throw_file_;
            a->throw_line_ = b->throw_line_;
            a->throw_function_ = b->throw_function_;
            a->throw_column_ = b->throw_column_;
            a->data_ = data;
            }

        inline
        void
        copy_boost_exception( void *, void const * )
            {
            }

        template <class T>
        class
        __attribute__((__visibility__("default")))
        clone_impl:
            public T,
            public virtual clone_base
            {
            struct clone_tag { };
            clone_impl( clone_impl const & x, clone_tag ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            public:

            explicit
            clone_impl( T const & x ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            ~clone_impl() noexcept
                {
                }

            private:

            clone_base const *
            clone() const
                {
                return new clone_impl(*this,clone_tag());
                }

            void
            rethrow() const
                {



                throw*this;

                }
            };
        }

    template <class T>
    inline
    exception_detail::clone_impl<T>
    enable_current_exception( T const & x )
        {
        return exception_detail::clone_impl<T>(x);
        }
    }
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 2 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 3
namespace boost
{
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 3
namespace detail
{

typedef char (&wrapexcept_s1)[ 1 ];
typedef char (&wrapexcept_s2)[ 2 ];

template<class T> wrapexcept_s1 wrapexcept_is_convertible( T* );
template<class T> wrapexcept_s2 wrapexcept_is_convertible( void* );

template<class E, class B, std::size_t I = sizeof( wrapexcept_is_convertible<B>( static_cast< E* >( nullptr ) ) ) > struct wrapexcept_add_base;

template<class E, class B> struct wrapexcept_add_base<E, B, 1>
{
    struct type {};
};

template<class E, class B> struct wrapexcept_add_base<E, B, 2>
{
    typedef B type;
};

}

template<class E> struct __attribute__((__visibility__("default"))) wrapexcept:
    public detail::wrapexcept_add_base<E, boost::exception_detail::clone_base>::type,
    public E,
    public detail::wrapexcept_add_base<E, boost::exception>::type
{
private:

    struct deleter
    {
        wrapexcept * p_;
        ~deleter() { delete p_; }
    };

private:

    void copy_from( void const* )
    {
    }

    void copy_from( boost::exception const* p )
    {
        static_cast<boost::exception&>( *this ) = *p;
    }

public:

    explicit wrapexcept( E const & e ): E( e )
    {
        copy_from( &e );
    }

    explicit wrapexcept( E const & e, boost::source_location const & loc ): E( e )
    {
        copy_from( &e );

        set_info( *this, throw_file( loc.file_name() ) );
        set_info( *this, throw_line( static_cast<int>( loc.line() ) ) );
        set_info( *this, throw_function( loc.function_name() ) );
        set_info( *this, throw_column( static_cast<int>( loc.column() ) ) );
    }

    virtual boost::exception_detail::clone_base const * clone() const override
    {
        wrapexcept * p = new wrapexcept( *this );
        deleter del = { p };

        boost::exception_detail::copy_boost_exception( p, this );

        del.p_ = nullptr;
        return p;
    }

    virtual void rethrow() const override
    {






        throw *this;


    }
};




inline void throw_exception_assert_compatibility( std::exception const & ) {}
# 162 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 3
template<class E> __attribute__ ((__noreturn__)) void throw_exception( E const & e )
{
    throw_exception_assert_compatibility( e );
    throw wrapexcept<E>( e );
}

template<class E> __attribute__ ((__noreturn__)) void throw_exception( E const & e, boost::source_location const & loc )
{
    throw_exception_assert_compatibility( e );
    throw wrapexcept<E>( e, loc );
}





}





namespace boost
{



namespace detail
{

struct __attribute__((__visibility__("default"))) throw_location
{
    boost::source_location location_;

    explicit throw_location( boost::source_location const & loc ): location_( loc )
    {
    }
};

template<class E> class __attribute__((__visibility__("default"))) with_throw_location: public E, public throw_location
{
public:

    with_throw_location( E const & e, boost::source_location const & loc ): E( e ), throw_location( loc )
    {
    }



    with_throw_location( E && e, boost::source_location const & loc ): E( std::move( e ) ), throw_location( loc )
    {
    }


};

}





template<class E> __attribute__ ((__noreturn__)) void throw_with_location( E && e, boost::source_location const & loc = ::boost::source_location(::std::source_location::current()) )
{
    throw_exception_assert_compatibility( e );
    throw detail::with_throw_location<typename std::decay<E>::type>( std::forward<E>( e ), loc );
}
# 251 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/throw_exception.hpp" 3
template<class E> boost::source_location get_throw_location( E const & e )
{







    if( detail::throw_location const* pl = dynamic_cast< detail::throw_location const* >( &e ) )
    {
        return pl->location_;
    }
    else if( boost::exception const* px = dynamic_cast< boost::exception const* >( &e ) )
    {
        return exception_detail::get_exception_throw_location( *px );
    }
    else
    {
        return boost::source_location();
    }


}

}
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/intrinsics.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/intrinsics.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/config.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/config.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/version.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/config.hpp" 2 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/intrinsics.hpp" 2 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/integral_constant.hpp" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/integral_constant.hpp" 3
namespace mpl_{

   template <bool B> struct bool_;
   template <class I, I val> struct integral_c;
   struct integral_c_tag;
}

namespace boost
{
   namespace mpl
   {
      using ::mpl_::bool_;
      using ::mpl_::integral_c;
      using ::mpl_::integral_c_tag;
   }
}



namespace boost{

   template <class T, T val>
   struct integral_constant
   {
      typedef mpl::integral_c_tag tag;
      typedef T value_type;
      typedef integral_constant<T, val> type;
      static const T value = val;

      operator const mpl::integral_c<T, val>& ()const
      {
         static const char data[sizeof(long)] = { 0 };
         const void* const pdata = data;
         return *static_cast<const mpl::integral_c<T, val>*>(pdata);
      }
      constexpr operator T()const noexcept { return val; }
      constexpr T operator()()const noexcept { return val; }
   };

   template <class T, T val>
   T const integral_constant<T, val>::value;

   template <bool val>
   struct integral_constant<bool, val>
   {
      typedef mpl::integral_c_tag tag;
      typedef bool value_type;
      typedef integral_constant<bool, val> type;
      static const bool value = val;

      operator const mpl::bool_<val>& ()const
      {
         static const char data[sizeof(long)] = { 0 };
         const void* const pdata = data;
         return *static_cast<const mpl::bool_<val>*>(pdata);
      }
      constexpr operator bool()const noexcept { return val; }
      constexpr bool operator()()const noexcept { return val; }
   };

   template <bool val>
   bool const integral_constant<bool, val>::value;

   typedef integral_constant<bool, true> true_type;
   typedef integral_constant<bool, false> false_type;

}
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 2 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 3
   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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/alignment_of.hpp" 3
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>{};


}
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/conditional.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/conditional.hpp" 3
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;



}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/conjunction.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/conjunction.hpp" 3
namespace boost {


template<class...>
struct conjunction
    : true_type { };

template<class T>
struct conjunction<T>
    : T { };

template<class T, class... U>
struct conjunction<T, U...>
    : conditional<bool(T::value), conjunction<U...>, T>::type { };






}
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/disjunction.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/disjunction.hpp" 3
namespace boost {


template<class...>
struct disjunction
    : false_type { };

template<class T>
struct disjunction<T>
    : T { };

template<class T, class... U>
struct disjunction<T, U...>
    : conditional<bool(T::value), T, disjunction<U...> >::type { };






}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_constructor.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_constructor.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/declval.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/declval.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_rvalue_reference.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_rvalue_reference.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_void.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_void.hpp" 3
namespace boost {

template <class T>
struct is_void : public false_type {};

template<> struct is_void<void> : public true_type {};
template<> struct is_void<const void> : public true_type{};
template<> struct is_void<const volatile void> : public true_type{};
template<> struct is_void<volatile void> : public true_type{};

}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_rvalue_reference.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_reference.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_reference.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_lvalue_reference.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_lvalue_reference.hpp" 3
namespace boost {





   template <class T> struct is_lvalue_reference : public false_type{};
   template <class T> struct is_lvalue_reference<T&> : public true_type{};
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_lvalue_reference.hpp" 3
}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_reference.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_rvalue_reference.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_rvalue_reference.hpp" 3
namespace boost {

template <class T> struct is_rvalue_reference : public false_type {};

template <class T> struct is_rvalue_reference<T&&> : public true_type {};


}
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_reference.hpp" 2 3

namespace boost {

template <class T> struct is_reference
   : public
   integral_constant<
      bool,
      ::boost::is_lvalue_reference<T>::value || ::boost::is_rvalue_reference<T>::value>
{};

}
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_rvalue_reference.hpp" 2 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_rvalue_reference.hpp" 3
namespace boost {

namespace type_traits_detail {

    template <typename T, bool b>
    struct add_rvalue_reference_helper
    { typedef T type; };


    template <typename T>
    struct add_rvalue_reference_helper<T, true>
    {
        typedef T&& type;
    };


    template <typename T>
    struct add_rvalue_reference_imp
    {
       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
                  <T, (is_void<T>::value == false && is_reference<T>::value == false) >::type type;
    };

}

template <class T> struct add_rvalue_reference
{
   typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
};



   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;



}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/declval.hpp" 2 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/declval.hpp" 3
namespace boost {

    template <typename T>
    typename add_rvalue_reference<T>::type declval() noexcept;

}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_reference.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_reference.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_reference.hpp" 3
   template <class T> using remove_reference_t = typename remove_reference<T>::type;



}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_function.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_function.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_function_cxx_11.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3
namespace boost {

   template <class T>
   struct is_function : public false_type {};
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3
   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)noexcept(NE)> : public true_type {};



   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const noexcept(NE)> : public true_type {};



   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile noexcept(NE)> : public true_type {};




   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)& noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)& noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const & noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile & noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile & noexcept(NE)> : public true_type {};




   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)&& noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)&& noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const && noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile && noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
# 669 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3
}
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_function.hpp" 2 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/yes_no_type.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/yes_no_type.hpp" 3
namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

}
}
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 2 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 3
namespace boost {
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 3
   namespace detail {

      template <std::size_t N>
      struct ok_tag { double d; char c[N]; };

      template <class T>
      ok_tag<sizeof(T)> check_is_complete(int);
      template <class T>
      char check_is_complete(...);

   }

   template <class T> struct is_complete
      : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_complete.hpp" 3
}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/static_assert.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 2 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 3
   }







   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
   };

   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};

   template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};


   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};

   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_default_constructible.hpp" 3
}
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3


namespace boost {

template <class T> struct has_nothrow_constructor : public integral_constant<bool, (__is_nothrow_constructible(T) && is_default_constructible<T>::value)>{};
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_constructor.hpp" 3
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>{};

}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/type_with_alignment.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/type_with_alignment.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pod.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pod.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_arithmetic.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_arithmetic.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_integral.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_integral.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_integral.hpp" 3
template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
template<> struct is_integral< ::boost::long_long_type> : public true_type{};






template<> struct is_integral<boost::int128_type> : public true_type{};
template<> struct is_integral<boost::uint128_type> : public true_type{};


template<> struct is_integral<char16_t> : public true_type{};


template<> struct is_integral<char32_t> : public true_type{};


template<> struct is_integral<char8_t> : public true_type{};




}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_arithmetic.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_floating_point.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_floating_point.hpp" 3
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{};
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_floating_point.hpp" 3
}
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_arithmetic.hpp" 2 3

namespace boost {

template <class T>
struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};

}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_enum.hpp" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_enum.hpp" 3
namespace boost {
# 160 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_enum.hpp" 3
template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> {};



}
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pointer.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pointer.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pointer.hpp" 3
}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_pointer.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_pointer.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_function_pointer.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_function_pointer.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3
namespace boost {
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3
   template <class T>
   struct is_member_function_pointer : public false_type {};
   template <class T>
   struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {};
   template <class T>
   struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {};
   template <class T>
   struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {};
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3
   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret (C::*)(Args..., ...)noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile noexcept(NE)> : public true_type {};



   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)& noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)& noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & noexcept(NE)> : public true_type {};



   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...) && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...) && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
# 695 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3
}
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_function_pointer.hpp" 2 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_member_pointer.hpp" 2 3

namespace boost {




template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};


template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};




}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_scalar.hpp" 2 3


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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pod.hpp" 2 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_pod.hpp" 3
namespace boost {


template< typename T > struct is_POD;

template <typename T> struct is_pod
: public integral_constant<bool, ::boost::is_scalar<T>::value || ::boost::is_void<T>::value || __is_pod(T)>
{};


template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};




template<> struct is_pod<void> : public true_type{};


template<> struct is_pod<void const> : public true_type{};
template<> struct is_pod<void const volatile> : public true_type{};
template<> struct is_pod<void volatile> : public true_type{};


template<class T> struct is_POD : public is_pod<T>{};

}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/type_with_alignment.hpp" 2 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/type_with_alignment.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/type_with_alignment.hpp" 3
}
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_const.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_const.hpp" 3
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;



}
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_array.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_array.hpp" 3
namespace boost {




   template <class T> struct is_array : public false_type {};

   template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
   template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
   template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
   template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};

   template <class T> struct is_array<T[]> : public true_type{};
   template <class T> struct is_array<T const[]> : public true_type{};
   template <class T> struct is_array<T const volatile[]> : public true_type{};
   template <class T> struct is_array<T volatile[]> : public true_type{};





}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_bounds.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_bounds.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_extent.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_extent.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_bounds.hpp" 2 3

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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_pointer.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_pointer.hpp" 3
namespace boost {
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/add_pointer.hpp" 3
template <typename T>
struct add_pointer
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};





   template <class T> using add_pointer_t = typename add_pointer<T>::type;



}
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_cv.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/remove_cv.hpp" 3
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;



}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/decay.hpp" 2 3

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;



}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_assignable.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_assignable.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_assignable.hpp" 3
}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_of.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_of.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_and_derived.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_and_derived.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_same.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_same.hpp" 3
namespace boost {


   template <class T, class U> struct is_same : public false_type {};
   template <class T> struct is_same<T,T> : public true_type {};







}
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_and_derived.hpp" 2 3

namespace boost {

namespace detail {
# 220 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_and_derived.hpp" 3
template <typename B, typename D>
struct is_base_and_derived_impl
{
    typedef typename remove_cv<B>::type ncvB;
    typedef typename remove_cv<D>::type ncvD;

    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};

}

template <class Base, class Derived> struct is_base_and_derived
   : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};

template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};





}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_of.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_class.hpp" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_class.hpp" 3
namespace boost {

namespace detail {
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_class.hpp" 3
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> {};






}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_base_of.hpp" 2 3

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{};

}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_const.hpp" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_const.hpp" 3
namespace boost {
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_const.hpp" 3
   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{};



}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_constructible.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_constructible.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_destructible.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_destructible.hpp" 3
namespace boost{

   namespace detail{

      struct is_destructible_imp
      {
         template<typename T, typename = decltype(boost::declval<T&>().~T())>
         static boost::type_traits::yes_type test(int);
         template<typename>
         static boost::type_traits::no_type test(...);
      };

   }

   template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types");
   };
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_destructible.hpp" 3
   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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_constructible.hpp" 2 3








namespace boost{

   namespace detail{

      struct is_constructible_imp
      {
         template<typename T, typename ...TheArgs, typename = decltype(T(boost::declval<TheArgs>()...))>
         static boost::type_traits::yes_type test(int);
         template<typename, typename...>
         static boost::type_traits::no_type test(...);

         template<typename T, typename Arg, typename = decltype(::new T(boost::declval<Arg>()))>
         static boost::type_traits::yes_type test1(int);
         template<typename, typename>
         static boost::type_traits::no_type test1(...);

         template <typename T>
         static boost::type_traits::yes_type ref_test(T);
         template <typename T>
         static boost::type_traits::no_type ref_test(...);
      };

   }

   template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
   };
   template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
   };
   template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
   template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};

   template <> struct is_constructible<void> : public false_type{};
   template <> struct is_constructible<void const> : public false_type{};
   template <> struct is_constructible<void const volatile> : public false_type{};
   template <> struct is_constructible<void volatile> : public false_type{};

   template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_constructible.hpp" 3
}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_convertible.hpp" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_convertible.hpp" 3
namespace boost {
# 489 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_convertible.hpp" 3
template <class From, class To>
struct is_convertible : public integral_constant<bool, __is_convertible_to(From,To)>
{





   static_assert(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
   static_assert(boost::is_complete<From>::value || boost::is_void<From>::value || boost::is_array<From>::value, "From argument type to is_convertible must be a complete type");

};



}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_trivial_move_assign.hpp" 1 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_trivial_move_assign.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_volatile.hpp" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_volatile.hpp" 3
namespace boost {
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_volatile.hpp" 3
   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{};



}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_trivial_move_assign.hpp" 2 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_trivial_move_assign.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_assign.hpp" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_assign.hpp" 3
namespace boost {
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_assign.hpp" 3
   template <class T>
   struct has_nothrow_assign : public integral_constant < bool,
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/has_nothrow_assign.hpp" 3
      (__is_nothrow_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)

   > {};

template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
template <> struct has_nothrow_assign<void> : public false_type{};
template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
template <class T> struct has_nothrow_assign<T&> : public false_type{};

template <class T> struct has_nothrow_assign<T&&> : public false_type{};


template <> struct has_nothrow_assign<void const> : public false_type{};
template <> struct has_nothrow_assign<void const volatile> : public false_type{};
template <> struct has_nothrow_assign<void volatile> : public false_type{};


}
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/enable_if.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/enable_if.hpp" 3
namespace boost {

template<bool B, class T = void>
struct enable_if_ {
    typedef T type;
};

template<class T>
struct enable_if_<false, T> { };


template<bool B, class T = void>
using enable_if_t = typename enable_if_<B, T>::type;


}
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3




namespace boost {
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3
namespace detail{

template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {};

template <class T>
struct false_or_cpp11_noexcept_move_assignable <
        T,
        typename ::boost::enable_if_<sizeof(T) && noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>::type
    > : public ::boost::integral_constant<bool, noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>
{};

}

template <class T>
struct is_nothrow_move_assignable : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value>
{
   static_assert(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
};

template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};

template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_constructible.hpp" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3
namespace boost{ namespace detail{

template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {};

template <class T>
struct false_or_cpp11_noexcept_move_constructible <
        T,
        typename ::boost::enable_if_<sizeof(T) && noexcept((T(::boost::declval<T>())))>::type
    > : public ::boost::integral_constant<bool, noexcept((T(::boost::declval<T>())))>
{};

}

template <class T> struct is_nothrow_move_constructible
   : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value>
{
   static_assert(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
};

template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3
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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none_t.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none_t.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/config/pragma_message.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none_t.hpp" 2 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none_t.hpp" 3
namespace boost {
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none_t.hpp" 3
struct none_t
{
  struct init_tag{};
  explicit constexpr none_t(init_tag){}
};



}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none.hpp" 2 3





namespace boost {
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/none.hpp" 3
inline constexpr none_t none ((none_t::init_tag()));



}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional_fwd.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional_fwd.hpp" 3
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;



}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_config.hpp" 1 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_factory_support.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_factory_support.hpp" 3
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 ;
}
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_aligned_storage.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_aligned_storage.hpp" 3
namespace boost {

namespace optional_detail {




template <class T>
class aligned_storage
{


    union __attribute__((__may_alias__)) dummy_u
    {
        unsigned char data[ sizeof(T) ];
        typename type_with_alignment<
          ::boost::alignment_of<T>::value >::type aligner_;
    } dummy_ ;

  public:


    void const* address() const { return &dummy_; }
    void * address() { return &dummy_; }







    T const* ptr_ref() const
    {
        union { void const* ap_pvoid; T const* as_ptype; } caster = { address() };
        return caster.as_ptype;
    }
    T * ptr_ref()
    {
        union { void* ap_pvoid; T* as_ptype; } caster = { address() };
        return caster.as_ptype;
    }





    T const& ref() const { return *boost::core::launder(ptr_ref()); }
    T & ref() { return *boost::core::launder(ptr_ref()); }
} ;

}
}
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_hash.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_hash.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  class bad_function_call : public std::exception
  {
  public:
    virtual ~bad_function_call() noexcept;

    const char* what() const noexcept;
  };







  template<typename _Tp>
    struct __is_location_invariant
    : is_trivially_copyable<_Tp>::type
    { };

  class _Undefined_class;

  union _Nocopy_types
  {
    void* _M_object;
    const void* _M_const_object;
    void (*_M_function_pointer)();
    void (_Undefined_class::*_M_member_pointer)();
  };

  union [[gnu::may_alias]] _Any_data
  {
    void* _M_access() noexcept { return &_M_pod_data[0]; }
    const void* _M_access() const noexcept { return &_M_pod_data[0]; }

    template<typename _Tp>
      _Tp&
      _M_access() noexcept
      { return *static_cast<_Tp*>(_M_access()); }

    template<typename _Tp>
      const _Tp&
      _M_access() const noexcept
      { return *static_cast<const _Tp*>(_M_access()); }

    _Nocopy_types _M_unused;
    char _M_pod_data[sizeof(_Nocopy_types)];
  };

  enum _Manager_operation
  {
    __get_type_info,
    __get_functor_ptr,
    __clone_functor,
    __destroy_functor
  };

  template<typename _Signature>
    class function;


  class _Function_base
  {
  public:
    static const size_t _M_max_size = sizeof(_Nocopy_types);
    static const size_t _M_max_align = __alignof__(_Nocopy_types);

    template<typename _Functor>
      class _Base_manager
      {
      protected:
 static const bool __stored_locally =
 (__is_location_invariant<_Functor>::value
  && sizeof(_Functor) <= _M_max_size
  && __alignof__(_Functor) <= _M_max_align
  && (_M_max_align % __alignof__(_Functor) == 0));

 using _Local_storage = integral_constant<bool, __stored_locally>;


 static _Functor*
 _M_get_pointer(const _Any_data& __source) noexcept
 {
   if constexpr (__stored_locally)
     {
       const _Functor& __f = __source._M_access<_Functor>();
       return const_cast<_Functor*>(std::__addressof(__f));
     }
   else
     return __source._M_access<_Functor*>();
 }

      private:


 template<typename _Fn>
   static void
   _M_create(_Any_data& __dest, _Fn&& __f, true_type)
   {
     ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f));
   }


 template<typename _Fn>
   static void
   _M_create(_Any_data& __dest, _Fn&& __f, false_type)
   {
     __dest._M_access<_Functor*>()
       = new _Functor(std::forward<_Fn>(__f));
   }


 static void
 _M_destroy(_Any_data& __victim, true_type)
 {
   __victim._M_access<_Functor>().~_Functor();
 }


 static void
 _M_destroy(_Any_data& __victim, false_type)
 {
   delete __victim._M_access<_Functor*>();
 }

      public:
 static bool
 _M_manager(_Any_data& __dest, const _Any_data& __source,
     _Manager_operation __op)
 {
   switch (__op)
     {
     case __get_type_info:

       __dest._M_access<const type_info*>() = &typeid(_Functor);



       break;

     case __get_functor_ptr:
       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
       break;

     case __clone_functor:
       _M_init_functor(__dest,
    *const_cast<const _Functor*>(_M_get_pointer(__source)));
       break;

     case __destroy_functor:
       _M_destroy(__dest, _Local_storage());
       break;
     }
   return false;
 }

 template<typename _Fn>
   static void
   _M_init_functor(_Any_data& __functor, _Fn&& __f)
   noexcept(__and_<_Local_storage,
     is_nothrow_constructible<_Functor, _Fn>>::value)
   {
     _M_create(__functor, std::forward<_Fn>(__f), _Local_storage());
   }

 template<typename _Signature>
   static bool
   _M_not_empty_function(const function<_Signature>& __f) noexcept
   { return static_cast<bool>(__f); }

 template<typename _Tp>
   static bool
   _M_not_empty_function(_Tp* __fp) noexcept
   { return __fp != nullptr; }

 template<typename _Class, typename _Tp>
   static bool
   _M_not_empty_function(_Tp _Class::* __mp) noexcept
   { return __mp != nullptr; }

 template<typename _Tp>
   static bool
   _M_not_empty_function(const _Tp&) noexcept
   { return true; }
      };

    _Function_base() = default;

    ~_Function_base()
    {
      if (_M_manager)
 _M_manager(_M_functor, _M_functor, __destroy_functor);
    }

    bool _M_empty() const { return !_M_manager; }

    using _Manager_type
      = bool (*)(_Any_data&, const _Any_data&, _Manager_operation);

    _Any_data _M_functor{};
    _Manager_type _M_manager{};
  };

  template<typename _Signature, typename _Functor>
    class _Function_handler;

  template<typename _Res, typename _Functor, typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), _Functor>
    : public _Function_base::_Base_manager<_Functor>
    {
      using _Base = _Function_base::_Base_manager<_Functor>;

    public:
      static bool
      _M_manager(_Any_data& __dest, const _Any_data& __source,
   _Manager_operation __op)
      {
 switch (__op)
   {

   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;

   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
     break;

   default:
     _Base::_M_manager(__dest, __source, __op);
   }
 return false;
      }

      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
      {
 return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
         std::forward<_ArgTypes>(__args)...);
      }

      template<typename _Fn>
 static constexpr bool
 _S_nothrow_init() noexcept
 {
   return __and_<typename _Base::_Local_storage,
   is_nothrow_constructible<_Functor, _Fn>>::value;
 }
    };


  template<>
    class _Function_handler<void, void>
    {
    public:
      static bool
      _M_manager(_Any_data&, const _Any_data&, _Manager_operation)
      { return false; }
    };





  template<typename _Signature, typename _Functor,
    bool __valid = is_object<_Functor>::value>
    struct _Target_handler
    : _Function_handler<_Signature, typename remove_cv<_Functor>::type>
    { };

  template<typename _Signature, typename _Functor>
    struct _Target_handler<_Signature, _Functor, false>
    : _Function_handler<void, void>
    { };






  template<typename _Res, typename... _ArgTypes>
    class function<_Res(_ArgTypes...)>
    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
      private _Function_base
    {


      template<typename _Func,
        bool _Self = is_same<__remove_cvref_t<_Func>, function>::value>
 using _Decay_t
   = typename __enable_if_t<!_Self, decay<_Func>>::type;

      template<typename _Func,
        typename _DFunc = _Decay_t<_Func>,
        typename _Res2 = __invoke_result<_DFunc&, _ArgTypes...>>
 struct _Callable
 : __is_invocable_impl<_Res2, _Res>::type
 { };

      template<typename _Cond, typename _Tp = void>
 using _Requires = __enable_if_t<_Cond::value, _Tp>;

      template<typename _Functor>
 using _Handler
   = _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>;

    public:
      typedef _Res result_type;







      function() noexcept
      : _Function_base() { }





      function(nullptr_t) noexcept
      : _Function_base() { }
# 388 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      function(const function& __x)
      : _Function_base()
      {
 if (static_cast<bool>(__x))
   {
     __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
     _M_invoker = __x._M_invoker;
     _M_manager = __x._M_manager;
   }
      }
# 406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      function(function&& __x) noexcept
      : _Function_base(), _M_invoker(__x._M_invoker)
      {
 if (static_cast<bool>(__x))
   {
     _M_functor = __x._M_functor;
     _M_manager = __x._M_manager;
     __x._M_manager = nullptr;
     __x._M_invoker = nullptr;
   }
      }
# 435 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      template<typename _Functor,
        typename _Constraints = _Requires<_Callable<_Functor>>>
 function(_Functor&& __f)
 noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
 : _Function_base()
 {
   static_assert(is_copy_constructible<__decay_t<_Functor>>::value,
       "std::function target must be copy-constructible");
   static_assert(is_constructible<__decay_t<_Functor>, _Functor>::value,
       "std::function target must be constructible from the "
       "constructor argument");

   using _My_handler = _Handler<_Functor>;

   if (_My_handler::_M_not_empty_function(__f))
     {
       _My_handler::_M_init_functor(_M_functor,
        std::forward<_Functor>(__f));
       _M_invoker = &_My_handler::_M_invoke;
       _M_manager = &_My_handler::_M_manager;
     }
 }
# 470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      function&
      operator=(const function& __x)
      {
 function(__x).swap(*this);
 return *this;
      }
# 488 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      function&
      operator=(function&& __x) noexcept
      {
 function(std::move(__x)).swap(*this);
 return *this;
      }
# 502 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 531 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      template<typename _Functor>
 _Requires<_Callable<_Functor>, function&>
 operator=(_Functor&& __f)
 noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
 {
   function(std::forward<_Functor>(__f)).swap(*this);
   return *this;
 }


      template<typename _Functor>
 function&
 operator=(reference_wrapper<_Functor> __f) noexcept
 {
   function(__f).swap(*this);
   return *this;
 }
# 558 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 575 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      explicit operator bool() const noexcept
      { return !_M_empty(); }
# 588 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      _Res
      operator()(_ArgTypes... __args) const
      {
 if (_M_empty())
   __throw_bad_function_call();
 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
      }
# 607 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      const type_info&
      target_type() const noexcept
      {
 if (_M_manager)
   {
     _Any_data __typeinfo_result;
     _M_manager(__typeinfo_result, _M_functor, __get_type_info);
     if (auto __ti = __typeinfo_result._M_access<const type_info*>())
       return *__ti;
   }
 return typeid(void);
      }
# 632 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
      template<typename _Functor>
 _Functor*
 target() noexcept
 {
   const function* __const_this = this;
   const _Functor* __func = __const_this->template target<_Functor>();


   return *const_cast<_Functor**>(&__func);
 }

      template<typename _Functor>
 const _Functor*
 target() const noexcept
 {
   if constexpr (is_object<_Functor>::value)
     {


       using _Handler = _Target_handler<_Res(_ArgTypes...), _Functor>;

       if (_M_manager == &_Handler::_M_manager

    || (_M_manager && typeid(_Functor) == target_type())

   )
  {
    _Any_data __ptr;
    _M_manager(__ptr, _M_functor, __get_functor_ptr);
    return __ptr._M_access<const _Functor*>();
  }
     }
   return nullptr;
 }


    private:
      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
      _Invoker_type _M_invoker = nullptr;
    };


  template<typename>
    struct __function_guide_helper
    { };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };
# 711 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_function.h" 3
  template<typename _StaticCallOp>
    struct __function_guide_static_helper
    { };

  template<typename _Res, bool _Nx, typename... _Args>
    struct __function_guide_static_helper<_Res (*) (_Args...) noexcept(_Nx)>
    { using type = _Res(_Args...); };

  template<typename _Fn, typename _Op>
    using __function_guide_t = typename __conditional_t<
      requires (_Fn& __f) { (void) __f.operator(); },
      __function_guide_static_helper<_Op>,
      __function_guide_helper<_Op>>::type;





  template<typename _Res, typename... _ArgTypes>
    function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;

  template<typename _Fn, typename _Signature
      = __function_guide_t<_Fn, decltype(&_Fn::operator())>>
    function(_Fn) -> function<_Signature>;
# 745 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 784 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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
      { };
  }



}
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_map" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_map" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable;

namespace __detail
{





  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Equal, typename _Hash, typename _RangeHash,
    typename _Unused, typename _Traits>
    struct _Hashtable_base;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"


  template<typename _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last)
    {
      using _Cat = typename std::iterator_traits<_Iterator>::iterator_category;
      if constexpr (is_convertible<_Cat, forward_iterator_tag>::value)
 return std::distance(__first, __last);
      else
 return __first != __last ? 1 : 0;
    }
#pragma GCC diagnostic pop

  struct _Identity
  {
    template<typename _Tp>
      _Tp&&
      operator()(_Tp&& __x) const noexcept
      { return std::forward<_Tp>(__x); }
  };

  struct _Select1st
  {
    template<typename _Pair>
      struct __1st_type;

    template<typename _Tp, typename _Up>
      struct __1st_type<pair<_Tp, _Up>>
      { using type = _Tp; };

    template<typename _Tp, typename _Up>
      struct __1st_type<const pair<_Tp, _Up>>
      { using type = const _Tp; };

    template<typename _Pair>
      struct __1st_type<_Pair&>
      { using type = typename __1st_type<_Pair>::type&; };

    template<typename _Tp>
      typename __1st_type<_Tp>::type&&
      operator()(_Tp&& __x) const noexcept
      { return std::forward<_Tp>(__x).first; }
  };

  template<typename _ExKey>
    struct _NodeBuilder;

  template<>
    struct _NodeBuilder<_Select1st>
    {
      template<typename _Kt, typename _Arg, typename _NodeGenerator>
 static auto
 _S_build(_Kt&& __k, _Arg&& __arg, _NodeGenerator& __node_gen)
 -> typename _NodeGenerator::__node_ptr
 {
   return __node_gen(std::forward<_Kt>(__k),
       std::forward<_Arg>(__arg).second);
 }
    };

  template<>
    struct _NodeBuilder<_Identity>
    {
      template<typename _Kt, typename _Arg, typename _NodeGenerator>
 static auto
 _S_build(_Kt&& __k, _Arg&&, _NodeGenerator& __node_gen)
 -> typename _NodeGenerator::__node_ptr
 { return __node_gen(std::forward<_Kt>(__k)); }
    };

  template<typename _HashtableAlloc, typename _NodePtr>
    struct _NodePtrGuard
    {
      _HashtableAlloc& _M_h;
      _NodePtr _M_ptr;

      ~_NodePtrGuard()
      {
 if (_M_ptr)
   _M_h._M_deallocate_node_ptr(_M_ptr);
      }
    };

  template<typename _NodeAlloc>
    struct _Hashtable_alloc;



  template<typename _NodeAlloc>
    struct _ReuseOrAllocNode
    {
    private:
      using __node_alloc_type = _NodeAlloc;
      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
      using __node_alloc_traits =
 typename __hashtable_alloc::__node_alloc_traits;

    public:
      using __node_ptr = typename __hashtable_alloc::__node_ptr;

      _ReuseOrAllocNode(__node_ptr __nodes, __hashtable_alloc& __h)
      : _M_nodes(__nodes), _M_h(__h) { }
      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;

      ~_ReuseOrAllocNode()
      { _M_h._M_deallocate_nodes(_M_nodes); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      template<typename _Arg>
 __node_ptr
 operator()(_Arg&& __arg)
 {
   if (!_M_nodes)
     return _M_h._M_allocate_node(std::forward<_Arg>(__arg));

   using value_type = typename _NodeAlloc::value_type::value_type;

   __node_ptr __node = _M_nodes;
   if constexpr (is_assignable<value_type&, _Arg>::value)
     {
       __node->_M_v() = std::forward<_Arg>(__arg);
       _M_nodes = _M_nodes->_M_next();
       __node->_M_nxt = nullptr;
     }
   else
     {
       _M_nodes = _M_nodes->_M_next();
       __node->_M_nxt = nullptr;
       auto& __a = _M_h._M_node_allocator();
       __node_alloc_traits::destroy(__a, __node->_M_valptr());
       _NodePtrGuard<__hashtable_alloc, __node_ptr>
  __guard{ _M_h, __node };
       __node_alloc_traits::construct(__a, __node->_M_valptr(),
          std::forward<_Arg>(__arg));
       __guard._M_ptr = nullptr;
     }
   return __node;
 }
#pragma GCC diagnostic pop

    private:
      __node_ptr _M_nodes;
      __hashtable_alloc& _M_h;
    };



  template<typename _NodeAlloc>
    struct _AllocNode
    {
    private:
      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;

    public:
      using __node_ptr = typename __hashtable_alloc::__node_ptr;

      _AllocNode(__hashtable_alloc& __h)
      : _M_h(__h) { }

      template<typename... _Args>
 __node_ptr
 operator()(_Args&&... __args) const
 { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); }

    private:
      __hashtable_alloc& _M_h;
    };
# 262 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
    struct _Hashtable_traits
    {
      using __hash_cached = __bool_constant<_Cache_hash_code>;
      using __constant_iterators = __bool_constant<_Constant_iterators>;
      using __unique_keys = __bool_constant<_Unique_keys>;
    };







  template<typename _Hash>
    struct _Hashtable_hash_traits
    {
      static constexpr size_t
      __small_size_threshold() noexcept
      { return std::__is_fast_hash<_Hash>::value ? 0 : 20; }
    };
# 292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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
    {
      using value_type = _Value;

      __gnu_cxx::__aligned_buffer<_Value> _M_storage;



      [[__gnu__::__always_inline__]]
      _Value*
      _M_valptr() noexcept
      { return _M_storage._M_ptr(); }

      [[__gnu__::__always_inline__]]
      const _Value*
      _M_valptr() const noexcept
      { return _M_storage._M_ptr(); }

      [[__gnu__::__always_inline__]]
      _Value&
      _M_v() noexcept
      { return *_M_valptr(); }

      [[__gnu__::__always_inline__]]
      const _Value&
      _M_v() const noexcept
      { return *_M_valptr(); }
    };




  template<bool _Cache_hash_code>
    struct _Hash_node_code_cache
    { };




  template<>
    struct _Hash_node_code_cache<true>
    { size_t _M_hash_code; };

  template<typename _Value, bool _Cache_hash_code>
    struct _Hash_node_value
    : _Hash_node_value_base<_Value>
    , _Hash_node_code_cache<_Cache_hash_code>
    { };




  template<typename _Value, bool _Cache_hash_code>
    struct _Hash_node
    : _Hash_node_base
    , _Hash_node_value<_Value, _Cache_hash_code>
    {
      _Hash_node*
      _M_next() const noexcept
      { return static_cast<_Hash_node*>(this->_M_nxt); }
    };


  template<typename _Value, bool _Cache_hash_code>
    struct _Node_iterator_base
    {
      using __node_type = _Hash_node<_Value, _Cache_hash_code>;

      __node_type* _M_cur;

      _Node_iterator_base() : _M_cur(nullptr) { }
      _Node_iterator_base(__node_type* __p) noexcept
      : _M_cur(__p) { }

      void
      _M_incr() noexcept
      { _M_cur = _M_cur->_M_next(); }

      friend bool
      operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y)
      noexcept
      { return __x._M_cur == __y._M_cur; }







    };


  template<typename _Value, bool __constant_iterators, bool __cache>
    struct _Node_iterator
    : public _Node_iterator_base<_Value, __cache>
    {
    private:
      using __base_type = _Node_iterator_base<_Value, __cache>;
      using __node_type = typename __base_type::__node_type;

    public:
      using value_type = _Value;
      using difference_type = ptrdiff_t;
      using iterator_category = forward_iterator_tag;

      using pointer = __conditional_t<__constant_iterators,
          const value_type*, value_type*>;

      using reference = __conditional_t<__constant_iterators,
     const value_type&, value_type&>;

      _Node_iterator() = default;

      explicit
      _Node_iterator(__node_type* __p) noexcept
      : __base_type(__p) { }

      reference
      operator*() const noexcept
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const noexcept
      { return this->_M_cur->_M_valptr(); }

      _Node_iterator&
      operator++() noexcept
      {
 this->_M_incr();
 return *this;
      }

      _Node_iterator
      operator++(int) noexcept
      {
 _Node_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }


      friend bool
      operator==(const _Node_iterator&, const _Node_iterator&) = default;
# 463 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
    };


  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;


      using __iterator
 = _Node_iterator<_Value, __constant_iterators, __cache>;

    public:
      using value_type = _Value;
      using difference_type = ptrdiff_t;
      using iterator_category = forward_iterator_tag;

      using pointer = const value_type*;
      using reference = const value_type&;

      _Node_const_iterator() = default;

      explicit
      _Node_const_iterator(__node_type* __p) noexcept
      : __base_type(__p) { }

      _Node_const_iterator(const __iterator& __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;
      }


      friend bool
      operator==(const _Node_const_iterator&,
   const _Node_const_iterator&) = default;

      friend bool
      operator==(const _Node_const_iterator& __x, const __iterator& __y)
      {
 const __base_type& __bx = __x;
 const __base_type& __by = __y;
 return __bx == __by;
      }
# 573 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
    };






  struct _Mod_range_hashing
  {
    size_t
    operator()(size_t __num, size_t __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; }



    size_t
    _M_next_bkt(size_t __n) const;


    size_t
    _M_bkt_for_elements(size_t __n) const
    { return __builtin_ceil(__n / (double)_M_max_load_factor); }






    std::pair<bool, size_t>
    _M_need_rehash(size_t __n_bkt, size_t __n_elt,
     size_t __n_ins) const;

    using _State = size_t;

    _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 size_t _S_growth_factor = 2;

    float _M_max_load_factor;


    mutable size_t _M_next_resize;
  };


  struct _Mask_range_hashing
  {
    size_t
    operator()(size_t __num, size_t __den) const noexcept
    { return __num & (__den - 1); }
  };


  inline size_t
  __clp2(size_t __n) noexcept
  {
    using __gnu_cxx::__int_traits;

    if (__n < 2)
      return __n;
    const unsigned __lz = sizeof(size_t) > sizeof(long)
      ? __builtin_clzll(__n - 1ull)
      : __builtin_clzl(__n - 1ul);

    return (size_t(1) << (__int_traits<size_t>::__digits - __lz - 1)) << 1;
  }



  struct _Power2_rehash_policy
  {
    using __has_load_factor = true_type;

    _Power2_rehash_policy(float __z = 1.0) noexcept
    : _M_max_load_factor(__z), _M_next_resize(0) { }

    float
    max_load_factor() const noexcept
    { return _M_max_load_factor; }



    size_t
    _M_next_bkt(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);
      size_t __res = __clp2(__n);

      if (__res == 0)
 __res = __max_bkt;
      else if (__res == 1)



 __res = 2;

      if (__res == __max_bkt)



 _M_next_resize = size_t(-1);
      else
 _M_next_resize
   = __builtin_floor(__res * (double)_M_max_load_factor);

      return __res;
    }


    size_t
    _M_bkt_for_elements(size_t __n) const noexcept
    { return __builtin_ceil(__n / (double)_M_max_load_factor); }





    std::pair<bool, size_t>
    _M_need_rehash(size_t __n_bkt, size_t __n_elt, size_t __n_ins) noexcept
    {
      if (__n_elt + __n_ins > _M_next_resize)
 {



   double __min_bkts
     = std::max<size_t>(__n_elt + __n_ins, _M_next_resize ? 0 : 11)
       / (double)_M_max_load_factor;
   if (__min_bkts >= __n_bkt)
     return { true,
       _M_next_bkt(std::max<size_t>(__builtin_floor(__min_bkts) + 1,
        __n_bkt * _S_growth_factor)) };

   _M_next_resize
     = __builtin_floor(__n_bkt * (double)_M_max_load_factor);
   return { false, 0 };
 }
      else
 return { false, 0 };
    }

    using _State = size_t;

    _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 size_t _S_growth_factor = 2;

    float _M_max_load_factor;
    size_t _M_next_resize;
  };

  template<typename _RehashPolicy>
    struct _RehashStateGuard
    {
      _RehashPolicy* _M_guarded_obj;
      typename _RehashPolicy::_State _M_prev_state;

      _RehashStateGuard(_RehashPolicy& __policy)
      : _M_guarded_obj(std::__addressof(__policy))
      , _M_prev_state(__policy._M_state())
      { }
      _RehashStateGuard(const _RehashStateGuard&) = delete;

      ~_RehashStateGuard()
      {
 if (_M_guarded_obj)
   _M_guarded_obj->_M_reset(_M_prev_state);
      }
    };
# 809 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    bool _Unique_keys = _Traits::__unique_keys::value>
    struct _Map_base { };


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>
    {
      using mapped_type = _Val;
    };


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>
    {
    private:
      using __hashtable_base = _Hashtable_base<_Key, pair<const _Key, _Val>,
            _Select1st, _Equal, _Hash,
            _RangeHash, _Unused,
            _Traits>;

      using __hashtable = _Hashtable<_Key, pair<const _Key, _Val>, _Alloc,
         _Select1st, _Equal, _Hash, _RangeHash,
         _Unused, _RehashPolicy, _Traits>;

      using __hash_code = typename __hashtable_base::__hash_code;

    public:
      using key_type = typename __hashtable_base::key_type;
      using mapped_type = _Val;

      mapped_type&
      operator[](const key_type& __k);

      mapped_type&
      operator[](key_type&& __k);



      mapped_type&
      at(const key_type& __k)
      {
 auto __ite = static_cast<__hashtable*>(this)->find(__k);
 if (!__ite._M_cur)
   __throw_out_of_range(("unordered_map::at"));
 return __ite->second;
      }

      const mapped_type&
      at(const key_type& __k) const
      {
 auto __ite = static_cast<const __hashtable*>(this)->find(__k);
 if (!__ite._M_cur)
   __throw_out_of_range(("unordered_map::at"));
 return __ite->second;
      }
    };

  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>::
    operator[](const key_type& __k)
    -> mapped_type&
    {
      __hashtable* __h = static_cast<__hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      size_t __bkt = __h->_M_bucket_index(__code);
      if (auto __node = __h->_M_find_node(__bkt, __k, __code))
 return __node->_M_v().second;

      typename __hashtable::_Scoped_node __node {
 __h,
 std::piecewise_construct,
 std::tuple<const key_type&>(__k),
 std::tuple<>()
      };
      auto __pos
 = __h->_M_insert_unique_node(__bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }

  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>::
    operator[](key_type&& __k)
    -> mapped_type&
    {
      __hashtable* __h = static_cast<__hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      size_t __bkt = __h->_M_bucket_index(__code);
      if (auto __node = __h->_M_find_node(__bkt, __k, __code))
 return __node->_M_v().second;

      typename __hashtable::_Scoped_node __node {
 __h,
 std::piecewise_construct,
 std::forward_as_tuple(std::move(__k)),
 std::tuple<>()
      };
      auto __pos
 = __h->_M_insert_unique_node(__bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits, bool __uniq>
    struct _Map_base<const _Key, pair<const _Key, _Val>,
       _Alloc, _Select1st, _Equal, _Hash,
       _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq>
    : _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal, _Hash,
  _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq>
    { };

  template<typename _Policy>
    using __has_load_factor = typename _Policy::__has_load_factor;







  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    typename =
      __detected_or_t<false_type, __has_load_factor, _RehashPolicy>>
    struct _Rehash_base;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits,
   false_type >
    {
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits,
   true_type >
    {
    private:
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

    public:
      float
      max_load_factor() const noexcept
      {
 const __hashtable* __this = static_cast<const __hashtable*>(this);
 return __this->__rehash_policy().max_load_factor();
      }

      void
      max_load_factor(float __z)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->__rehash_policy(_RehashPolicy(__z));
      }

      void
      reserve(size_t __n)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n));
      }
    };






  template<typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Hashtable_ebo_helper
    {
      [[__no_unique_address__]] _Tp _M_obj;
    };




  template<typename _Tp>
    struct _Hashtable_ebo_helper<_Tp, false>
    {
      _Tp _M_obj;
    };
# 1034 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __cache_hash_code>
    struct _Local_iterator_base;


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool >
    struct _Hash_code_base
    {

      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, false>;
    public:
      using hasher = _Hash;

      hasher
      hash_function() const
      { return _M_hash._M_obj; }

    protected:
      [[__no_unique_address__]] _Hashtable_ebo_helper<_Hash> _M_hash{};

      using __hash_code = size_t;



      _Hash_code_base() = default;

      _Hash_code_base(const _Hash& __hash) : _M_hash{__hash} { }

      __hash_code
      _M_hash_code(const _Key& __k) const
      {
 static_assert(__is_invocable<const _Hash&, const _Key&>{},
     "hash function must be invocable with an argument of key type");
 return _M_hash._M_obj(__k);
      }

      template<typename _Kt>
 __hash_code
 _M_hash_code_tr(const _Kt& __k) const
 {
   static_assert(__is_invocable<const _Hash&, const _Kt&>{},
     "hash function must be invocable with an argument of key type");
   return _M_hash._M_obj(__k);
 }

      __hash_code
      _M_hash_code(const _Hash_node_value<_Value, false>& __n) const
      { return _M_hash_code(_ExtractKey{}(__n._M_v())); }

      __hash_code
      _M_hash_code(const _Hash_node_value<_Value, true>& __n) const
      { return __n._M_hash_code; }

      size_t
      _M_bucket_index(__hash_code __c, size_t __bkt_count) const
      { return _RangeHash{}(__c, __bkt_count); }

      size_t
      _M_bucket_index(const _Hash_node_value<_Value, false>& __n,
        size_t __bkt_count) const
      noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>())) )
      {
 return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())),
       __bkt_count);
      }

      size_t
      _M_bucket_index(const _Hash_node_value<_Value, true>& __n,
        size_t __bkt_count) const noexcept
      { return _RangeHash{}(__n._M_hash_code, __bkt_count); }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _Hash, _RangeHash, _Unused, true>
    : public _Node_iterator_base<_Value, true>
    {
    protected:
      using __base_node_iter = _Node_iterator_base<_Value, true>;
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
           _Hash, _RangeHash, _Unused, true>;

      _Local_iterator_base() = default;

      _Local_iterator_base(const __hash_code_base&,
      _Hash_node<_Value, true>* __p,
      size_t __bkt, size_t __bkt_count)
      : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
      { }

      void
      _M_incr()
      {
 __base_node_iter::_M_incr();
 if (this->_M_cur)
   {
     size_t __bkt
       = _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count);
     if (__bkt != _M_bucket)
       this->_M_cur = nullptr;
   }
      }

      size_t _M_bucket = 0;
      size_t _M_bucket_count = 0;

    public:
      size_t
      _M_get_bucket() const { return _M_bucket; }
    };




  template<typename _Hash>
    struct _Hash_obj_storage
    {
      union _Uninit_storage
      {
 _Uninit_storage() noexcept { }
 ~_Uninit_storage() { }

 [[__no_unique_address__]] _Hash _M_h;
      };

      [[__no_unique_address__]] _Uninit_storage _M_u;
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _Hash, _RangeHash, _Unused, false>
    : _Hash_obj_storage<_Hash>, _Node_iterator_base<_Value, false>
    {
    protected:
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
          _Hash, _RangeHash, _Unused, false>;
      using __hash_obj_storage = _Hash_obj_storage<_Hash>;
      using __node_iter_base = _Node_iterator_base<_Value, false>;

      _Local_iterator_base() = default;

      _Local_iterator_base(const __hash_code_base& __base,
      _Hash_node<_Value, false>* __p,
      size_t __bkt, size_t __bkt_count)
      : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
      { _M_init(__base._M_hash._M_obj); }

      ~_Local_iterator_base()
      {
 if (_M_bucket_count != size_t(-1))
   _M_destroy();
      }

      _Local_iterator_base(const _Local_iterator_base& __iter)
      : __node_iter_base(__iter._M_cur), _M_bucket(__iter._M_bucket)
      , _M_bucket_count(__iter._M_bucket_count)
      {
 if (_M_bucket_count != size_t(-1))
   _M_init(__iter._M_h());
      }

      _Local_iterator_base&
      operator=(const _Local_iterator_base& __iter)
      {
 if (_M_bucket_count != size_t(-1))
   _M_destroy();
 this->_M_cur = __iter._M_cur;
 _M_bucket = __iter._M_bucket;
 _M_bucket_count = __iter._M_bucket_count;
 if (_M_bucket_count != size_t(-1))
   _M_init(__iter._M_h());
 return *this;
      }

      void
      _M_incr()
      {
 __node_iter_base::_M_incr();
 if (this->_M_cur)
   {
     const auto __code = _M_h()(_ExtractKey{}(this->_M_cur->_M_v()));
     size_t __bkt = _RangeHash{}(__code, _M_bucket_count);
     if (__bkt != _M_bucket)
       this->_M_cur = nullptr;
   }
      }

      size_t _M_bucket = 0;
      size_t _M_bucket_count = -1;

      void
      _M_init(const _Hash& __h)
      { std::_Construct(std::__addressof(__hash_obj_storage::_M_u._M_h), __h); }

      void
      _M_destroy() { __hash_obj_storage::_M_u._M_h.~_Hash(); }

      const _Hash&
      _M_h() const { return __hash_obj_storage::_M_u._M_h; }

    public:
      size_t
      _M_get_bucket() const { return _M_bucket; }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __constant_iterators, bool __cache>
    struct _Local_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;

    public:
      using value_type = _Value;
      using pointer = __conditional_t<__constant_iterators,
          const value_type*, value_type*>;
      using reference = __conditional_t<__constant_iterators,
     const value_type&, value_type&>;
      using difference_type = ptrdiff_t;
      using iterator_category = forward_iterator_tag;

      _Local_iterator() = default;

      _Local_iterator(const __hash_code_base& __base,
        _Hash_node<_Value, __cache>* __n,
        size_t __bkt, size_t __bkt_count)
      : __base_type(__base, __n, __bkt, __bkt_count)
      { }

      reference
      operator*() const
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const
      { return this->_M_cur->_M_valptr(); }

      _Local_iterator&
      operator++()
      {
 this->_M_incr();
 return *this;
      }

      _Local_iterator
      operator++(int)
      {
 _Local_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __constant_iterators, bool __cache>
    struct _Local_const_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;

    public:
      using value_type = _Value;
      using pointer = const value_type*;
      using reference = const value_type&;
      using difference_type = ptrdiff_t;
      using iterator_category = forward_iterator_tag;

      _Local_const_iterator() = default;

      _Local_const_iterator(const __hash_code_base& __base,
       _Hash_node<_Value, __cache>* __n,
       size_t __bkt, size_t __bkt_count)
      : __base_type(__base, __n, __bkt, __bkt_count)
      { }

      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused,
        __constant_iterators,
        __cache>& __x)
      : __base_type(__x)
      { }

      reference
      operator*() const
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const
      { return this->_M_cur->_M_valptr(); }

      _Local_const_iterator&
      operator++()
      {
 this->_M_incr();
 return *this;
      }

      _Local_const_iterator
      operator++(int)
      {
 _Local_const_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };
# 1369 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Equal, typename _Hash, typename _RangeHash,
    typename _Unused, typename _Traits>
    struct _Hashtable_base
    : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash,
        _Unused, _Traits::__hash_cached::value>
    {
    public:
      using key_type = _Key;
      using value_type = _Value;
      using key_equal = _Equal;
      using size_type = size_t;
      using difference_type = ptrdiff_t;

      using __traits_type = _Traits;
      using __hash_cached = typename __traits_type::__hash_cached;

      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
            _Hash, _RangeHash, _Unused,
            __hash_cached::value>;

      using __hash_code = typename __hash_code_base::__hash_code;

    protected:
      [[__no_unique_address__]] _Hashtable_ebo_helper<_Equal> _M_equal{};

      _Hashtable_base() = default;

      _Hashtable_base(const _Hash& __hash, const _Equal& __eq)
      : __hash_code_base(__hash), _M_equal{__eq}
      { }

      bool
      _M_key_equals(const _Key& __k,
      const _Hash_node_value<_Value,
        __hash_cached::value>& __n) const
      {
 static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
   "key equality predicate must be invocable with two arguments of "
   "key type");
 return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
      }

      template<typename _Kt>
 bool
 _M_key_equals_tr(const _Kt& __k,
    const _Hash_node_value<_Value,
          __hash_cached::value>& __n) const
 {
   static_assert(
     __is_invocable<const _Equal&, const _Kt&, const _Key&>{},
     "key equality predicate must be invocable with the argument type "
     "and the key type");
   return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
 }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      bool
      _M_equals(const _Key& __k, __hash_code __c,
  const _Hash_node_value<_Value, __hash_cached::value>& __n) const
      {
 if constexpr (__hash_cached::value)
   if (__c != __n._M_hash_code)
     return false;

 return _M_key_equals(__k, __n);
      }

      template<typename _Kt>
 bool
 _M_equals_tr(const _Kt& __k, __hash_code __c,
       const _Hash_node_value<_Value,
         __hash_cached::value>& __n) const
 {
   if constexpr (__hash_cached::value)
     if (__c != __n._M_hash_code)
       return false;

   return _M_key_equals_tr(__k, __n);
 }

      bool
      _M_node_equals(
 const _Hash_node_value<_Value, __hash_cached::value>& __lhn,
 const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const
      {
 if constexpr (__hash_cached::value)
   if (__lhn._M_hash_code != __rhn._M_hash_code)
     return false;

 return _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn);
      }
#pragma GCC diagnostic pop

      const _Equal&
      _M_eq() const noexcept { return _M_equal._M_obj; }
    };




  template<typename _NodeAlloc>
    struct _Hashtable_alloc
    {
    private:
      [[__no_unique_address__]] _Hashtable_ebo_helper<_NodeAlloc> _M_alloc{};

      template<typename>
 struct __get_value_type;
      template<typename _Val, bool _Cache_hash_code>
 struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>>
 { using type = _Val; };

    public:
      using __node_type = typename _NodeAlloc::value_type;
      using __node_alloc_type = _NodeAlloc;

      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;

      using __value_alloc_traits = typename __node_alloc_traits::template
 rebind_traits<typename __get_value_type<__node_type>::type>;

      using __node_ptr = __node_type*;
      using __node_base = _Hash_node_base;
      using __node_base_ptr = __node_base*;
      using __buckets_alloc_type =
 __alloc_rebind<__node_alloc_type, __node_base_ptr>;
      using __buckets_alloc_traits = std::allocator_traits<__buckets_alloc_type>;
      using __buckets_ptr = __node_base_ptr*;

      _Hashtable_alloc() = default;
      _Hashtable_alloc(const _Hashtable_alloc&) = default;
      _Hashtable_alloc(_Hashtable_alloc&&) = default;

      template<typename _Alloc>
 _Hashtable_alloc(_Alloc&& __a)
 : _M_alloc{std::forward<_Alloc>(__a)}
 { }

      __node_alloc_type&
      _M_node_allocator()
      { return _M_alloc._M_obj; }

      const __node_alloc_type&
      _M_node_allocator() const
      { return _M_alloc._M_obj; }


      template<typename... _Args>
 __node_ptr
 _M_allocate_node(_Args&&... __args);


      void
      _M_deallocate_node(__node_ptr __n);


      void
      _M_deallocate_node_ptr(__node_ptr __n);



      void
      _M_deallocate_nodes(__node_ptr __n);

      __buckets_ptr
      _M_allocate_buckets(size_t __bkt_count);

      void
      _M_deallocate_buckets(__buckets_ptr, size_t __bkt_count);
    };



  template<typename _NodeAlloc>
    template<typename... _Args>
      auto
      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
      -> __node_ptr
      {
 auto& __alloc = _M_node_allocator();
 auto __nptr = __node_alloc_traits::allocate(__alloc, 1);
 __node_ptr __n = std::__to_address(__nptr);
 try
   {
     ::new ((void*)__n) __node_type;
     __node_alloc_traits::construct(__alloc, __n->_M_valptr(),
        std::forward<_Args>(__args)...);
     return __n;
   }
 catch(...)
   {
     __n->~__node_type();
     __node_alloc_traits::deallocate(__alloc, __nptr, 1);
     throw;
   }
      }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_ptr __n)
    {
      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
      _M_deallocate_node_ptr(__n);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_ptr __n)
    {
      using _Ptr = typename __node_alloc_traits::pointer;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
      __n->~__node_type();
      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_ptr __n)
    {
      while (__n)
 {
   __node_ptr __tmp = __n;
   __n = __n->_M_next();
   _M_deallocate_node(__tmp);
 }
    }

  template<typename _NodeAlloc>
    auto
    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(size_t __bkt_count)
    -> __buckets_ptr
    {
      __buckets_alloc_type __alloc(_M_node_allocator());

      auto __ptr = __buckets_alloc_traits::allocate(__alloc, __bkt_count);
      __buckets_ptr __p = std::__to_address(__ptr);
      __builtin_memset(__p, 0, __bkt_count * sizeof(__node_base_ptr));
      return __p;
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::
    _M_deallocate_buckets(__buckets_ptr __bkts, size_t __bkt_count)
    {
      using _Ptr = typename __buckets_alloc_traits::pointer;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
      __buckets_alloc_type __alloc(_M_node_allocator());
      __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count);
    }


}


}
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/enable_special_members.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 { };
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
  };



}
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 2 3






#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Hash>
    using __cache_default
      = __not_<__and_<
         __is_fast_hash<_Hash>,

         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;




  template<typename _Equal, typename _Hash, typename _Allocator>
    using _Hashtable_enable_default_ctor
      = _Enable_default_constructor<__and_<is_default_constructible<_Equal>,
           is_default_constructible<_Hash>,
           is_default_constructible<_Allocator>>{},
        __detail::_Hash_node_base>;
# 185 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable
    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
           _Hash, _RangeHash, _Unused, _Traits>,
      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits>,
      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused,
        _RehashPolicy, _Traits>,
      private __detail::_Hashtable_alloc<
 __alloc_rebind<_Alloc,
         __detail::_Hash_node<_Value,
         _Traits::__hash_cached::value>>>,
      private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>
    {
      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
   "unordered container must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Value>{},
   "unordered container must have the same value_type as its allocator");

      static_assert(is_copy_constructible<_Hash>::value,
   "hash function must be copy constructible");

      using __traits_type = _Traits;
      using __hash_cached = typename __traits_type::__hash_cached;
      using __constant_iterators = typename __traits_type::__constant_iterators;
      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;

      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;

      using __node_value_type =
 __detail::_Hash_node_value<_Value, __hash_cached::value>;
      using __node_ptr = typename __hashtable_alloc::__node_ptr;
      using __value_alloc_traits =
 typename __hashtable_alloc::__value_alloc_traits;
      using __node_alloc_traits =
 typename __hashtable_alloc::__node_alloc_traits;
      using __node_base = typename __hashtable_alloc::__node_base;
      using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr;
      using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr;

      using __enable_default_ctor
 = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>;
      using __rehash_guard_t
 = __detail::_RehashStateGuard<_RehashPolicy>;

    public:
      typedef _Key key_type;
      typedef _Value value_type;
      typedef _Alloc allocator_type;
      typedef _Equal key_equal;



      typedef typename __value_alloc_traits::pointer pointer;
      typedef typename __value_alloc_traits::const_pointer const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;

      using iterator
 = __detail::_Node_iterator<_Value, __constant_iterators::value,
       __hash_cached::value>;

      using const_iterator
 = __detail::_Node_const_iterator<_Value, __constant_iterators::value,
      __hash_cached::value>;

      using local_iterator = __detail::_Local_iterator<key_type, _Value,
   _ExtractKey, _Hash, _RangeHash, _Unused,
          __constant_iterators::value,
          __hash_cached::value>;

      using const_local_iterator = __detail::_Local_const_iterator<
   key_type, _Value,
   _ExtractKey, _Hash, _RangeHash, _Unused,
   __constant_iterators::value, __hash_cached::value>;

    private:
      using __rehash_type = _RehashPolicy;

      using __unique_keys = typename __traits_type::__unique_keys;

      using __hashtable_base = __detail::
 _Hashtable_base<_Key, _Value, _ExtractKey,
   _Equal, _Hash, _RangeHash, _Unused, _Traits>;

      using __hash_code_base = typename __hashtable_base::__hash_code_base;
      using __hash_code = typename __hashtable_base::__hash_code;
      using __ireturn_type = __conditional_t<__unique_keys::value,
          std::pair<iterator, bool>,
          iterator>;

      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
          _Equal, _Hash, _RangeHash, _Unused,
          _RehashPolicy, _Traits>;

      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
         _ExtractKey, _Equal,
         _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

      using __node_builder_t = __detail::_NodeBuilder<_ExtractKey>;


      struct _Scoped_node
      {

 _Scoped_node(__node_ptr __n, __hashtable_alloc* __h)
 : _M_h(__h), _M_node(__n) { }


 template<typename... _Args>
   _Scoped_node(__hashtable_alloc* __h, _Args&&... __args)
   : _M_h(__h),
     _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...))
   { }


 ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); };

 _Scoped_node(const _Scoped_node&) = delete;
 _Scoped_node& operator=(const _Scoped_node&) = delete;

 __hashtable_alloc* _M_h;
 __node_ptr _M_node;
      };





      struct __hash_code_base_access : __hash_code_base
      { using __hash_code_base::_M_bucket_index; };


      static_assert(is_nothrow_default_constructible<_RangeHash>::value,
      "Functor used to map hash code to bucket index"
      " must be nothrow default constructible");
      static_assert(noexcept(
 std::declval<const _RangeHash&>()((std::size_t)0, (std::size_t)0)),
      "Functor used to map hash code to bucket index must be"
      " noexcept");


      static_assert(is_nothrow_default_constructible<_ExtractKey>::value,
      "_ExtractKey must be nothrow default constructible");
      static_assert(noexcept(
 std::declval<const _ExtractKey&>()(std::declval<_Value>())),
      "_ExtractKey functor must be noexcept invocable");

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _Hasha, typename _RangeHasha, typename _Unuseda,
        typename _RehashPolicya, typename _Traitsa,
        bool _Unique_keysa>
 friend struct __detail::_Map_base;

    public:
      using size_type = typename __hashtable_base::size_type;
      using difference_type = typename __hashtable_base::difference_type;


      using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
      using insert_return_type = _Node_insert_return<iterator, node_type>;


    private:
      __buckets_ptr _M_buckets = &_M_single_bucket;
      size_type _M_bucket_count = 1;
      __node_base _M_before_begin;
      size_type _M_element_count = 0;
      _RehashPolicy _M_rehash_policy;







      __node_base_ptr _M_single_bucket = nullptr;

      void
      _M_update_bbegin()
      {
 if (auto __begin = _M_begin())
   _M_buckets[_M_bucket_index(*__begin)] = &_M_before_begin;
      }

      void
      _M_update_bbegin(__node_ptr __n)
      {
 _M_before_begin._M_nxt = __n;
 _M_update_bbegin();
      }

      bool
      _M_uses_single_bucket(__buckets_ptr __bkts) const
      { return __builtin_expect(__bkts == &_M_single_bucket, false); }

      bool
      _M_uses_single_bucket() const
      { return _M_uses_single_bucket(_M_buckets); }

      static constexpr size_t
      __small_size_threshold() noexcept
      {
 return
   __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold();
      }

      __hashtable_alloc&
      _M_base_alloc() { return *this; }

      __buckets_ptr
      _M_allocate_buckets(size_type __bkt_count)
      {
 if (__builtin_expect(__bkt_count == 1, false))
   {
     _M_single_bucket = nullptr;
     return &_M_single_bucket;
   }

 return __hashtable_alloc::_M_allocate_buckets(__bkt_count);
      }

      void
      _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count)
      {
 if (_M_uses_single_bucket(__bkts))
   return;

 __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count);
      }

      void
      _M_deallocate_buckets()
      { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }



      __node_ptr
      _M_bucket_begin(size_type __bkt) const
      {
 __node_base_ptr __n = _M_buckets[__bkt];
 return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr;
      }

      __node_ptr
      _M_begin() const
      { return static_cast<__node_ptr>(_M_before_begin._M_nxt); }



      template<typename _Ht>
 void
 _M_assign_elements(_Ht&&);

      template<typename _Ht>
 void
 _M_assign(_Ht&& __ht)
 {
   __detail::_AllocNode<__node_alloc_type> __alloc_node_gen(*this);
   _M_assign(std::forward<_Ht>(__ht), __alloc_node_gen);
 }

      template<typename _Ht, typename _NodeGenerator>
 void
 _M_assign(_Ht&&, _NodeGenerator&);

      void
      _M_move_assign(_Hashtable&&, true_type);

      void
      _M_move_assign(_Hashtable&&, false_type);

      void
      _M_reset() noexcept;

      _Hashtable(const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a)
      : __hashtable_base(__h, __eq),
 __hashtable_alloc(__node_alloc_type(__a)),
 __enable_default_ctor(_Enable_default_constructor_tag{})
      { }

      template<bool _No_realloc = true>
 static constexpr bool
 _S_nothrow_move()
 {





   if constexpr (_No_realloc)
     if constexpr (is_nothrow_copy_constructible<_Hash>())
       return is_nothrow_copy_constructible<_Equal>();
   return false;

 }

      _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
   true_type )
 noexcept(_S_nothrow_move());

      _Hashtable(_Hashtable&&, __node_alloc_type&&,
   false_type );

      template<typename _InputIterator>
 _Hashtable(_InputIterator __first, _InputIterator __last,
     size_type __bkt_count_hint,
     const _Hash&, const _Equal&, const allocator_type&,
     true_type __uks);

      template<typename _InputIterator>
 _Hashtable(_InputIterator __first, _InputIterator __last,
     size_type __bkt_count_hint,
     const _Hash&, const _Equal&, const allocator_type&,
     false_type __uks);

    public:

      _Hashtable() = default;

      _Hashtable(const _Hashtable&);

      _Hashtable(const _Hashtable&, const allocator_type&);

      explicit
      _Hashtable(size_type __bkt_count_hint,
   const _Hash& __hf = _Hash(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type());


      _Hashtable(_Hashtable&& __ht)
 noexcept(_S_nothrow_move())
      : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()),
     true_type{})
      { }

      _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
 noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>())
      : _Hashtable(std::move(__ht), __node_alloc_type(__a),
     typename __node_alloc_traits::is_always_equal{})
      { }

      explicit
      _Hashtable(const allocator_type& __a)
      : __hashtable_alloc(__node_alloc_type(__a)),
 __enable_default_ctor(_Enable_default_constructor_tag{})
      { }

      template<typename _InputIterator>
 _Hashtable(_InputIterator __f, _InputIterator __l,
     size_type __bkt_count_hint = 0,
     const _Hash& __hf = _Hash(),
     const key_equal& __eql = key_equal(),
     const allocator_type& __a = allocator_type())
 : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a,
       __unique_keys{})
 { }

      _Hashtable(initializer_list<value_type> __l,
   size_type __bkt_count_hint = 0,
   const _Hash& __hf = _Hash(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type())
      : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,
     __hf, __eql, __a, __unique_keys{})
      { }

      _Hashtable&
      operator=(const _Hashtable& __ht);

      _Hashtable&
      operator=(_Hashtable&& __ht)
      noexcept(__node_alloc_traits::_S_nothrow_move()
        && is_nothrow_move_assignable<_Hash>::value
        && is_nothrow_move_assignable<_Equal>::value)
      {
 constexpr bool __move_storage =
   __node_alloc_traits::_S_propagate_on_move_assign()
   || __node_alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
 return *this;
      }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      _Hashtable&
      operator=(initializer_list<value_type> __l)
      {
 using __reuse_or_alloc_node_gen_t =
   __detail::_ReuseOrAllocNode<__node_alloc_type>;

 __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
 _M_before_begin._M_nxt = nullptr;
 clear();


 auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size());



 if (_M_bucket_count < __l_bkt_count)
   rehash(__l_bkt_count);

 __hash_code __code;
 size_type __bkt;
 for (auto& __e : __l)
   {
     const key_type& __k = _ExtractKey{}(__e);

     if constexpr (__unique_keys::value)
       {
  if (auto __loc = _M_locate(__k))
    continue;
  else
    {
      __code = __loc._M_hash_code;
      __bkt = __loc._M_bucket_index;
    }
       }
     else
       {
  __code = this->_M_hash_code(__k);
  __bkt = _M_bucket_index(__code);
       }

     _M_insert_unique_node(__bkt, __code, __roan(__e));
   }

 return *this;
      }
#pragma GCC diagnostic pop

      ~_Hashtable() noexcept;

      void
      swap(_Hashtable&)
      noexcept(__and_<__is_nothrow_swappable<_Hash>,
        __is_nothrow_swappable<_Equal>>::value);


      iterator
      begin() noexcept
      { return iterator(_M_begin()); }

      const_iterator
      begin() const noexcept
      { return const_iterator(_M_begin()); }

      iterator
      end() noexcept
      { return iterator(nullptr); }

      const_iterator
      end() const noexcept
      { return const_iterator(nullptr); }

      const_iterator
      cbegin() const noexcept
      { return const_iterator(_M_begin()); }

      const_iterator
      cend() const noexcept
      { return const_iterator(nullptr); }

      size_type
      size() const noexcept
      { return _M_element_count; }

      [[__nodiscard__]] bool
      empty() const noexcept
      { return size() == 0; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(this->_M_node_allocator()); }

      size_type
      max_size() const noexcept
      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }


      key_equal
      key_eq() const
      { return this->_M_eq(); }




      size_type
      bucket_count() const noexcept
      { return _M_bucket_count; }

      size_type
      max_bucket_count() const noexcept
      { return max_size(); }

      size_type
      bucket_size(size_type __bkt) const
      { return std::distance(begin(__bkt), end(__bkt)); }

      size_type
      bucket(const key_type& __k) const
      { return _M_bucket_index(this->_M_hash_code(__k)); }

      local_iterator
      begin(size_type __bkt)
      {
 return local_iterator(*this, _M_bucket_begin(__bkt),
         __bkt, _M_bucket_count);
      }

      local_iterator
      end(size_type __bkt)
      { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      const_local_iterator
      begin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      end(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }


      const_local_iterator
      cbegin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      cend(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      float
      load_factor() const noexcept
      {
 return static_cast<float>(size()) / static_cast<float>(bucket_count());
      }






      const _RehashPolicy&
      __rehash_policy() const
      { return _M_rehash_policy; }

      void
      __rehash_policy(const _RehashPolicy& __pol)
      { _M_rehash_policy = __pol; }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      std::pair<iterator, iterator>
      equal_range(const key_type& __k);

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;


      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 iterator
 _M_find_tr(const _Kt& __k);

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 const_iterator
 _M_find_tr(const _Kt& __k) const;

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 size_type
 _M_count_tr(const _Kt& __k) const;

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 pair<iterator, iterator>
 _M_equal_range_tr(const _Kt& __k);

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 pair<const_iterator, const_iterator>
 _M_equal_range_tr(const _Kt& __k) const;


      void _M_rehash_insert(size_type __n);

    private:

      size_type
      _M_bucket_index(const __node_value_type& __n) const noexcept
      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }

      size_type
      _M_bucket_index(__hash_code __c) const
      { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"



      __hash_code
      _M_hash_code_ext(const __node_value_type& __from) const
      {
 if constexpr (__and_<__hash_cached, is_empty<_Hash>>::value)
   return __from._M_hash_code;
 else
   return this->_M_hash_code(_ExtractKey{}(__from._M_v()));
      }



      size_type
      _M_bucket_index_ext(const __node_value_type& __from) const
      { return _RangeHash{}(_M_hash_code_ext(__from), _M_bucket_count); }

      void
      _M_copy_code(__node_value_type& __to,
     const __node_value_type& __from) const
      {
 if constexpr (__hash_cached::value)
   __to._M_hash_code = _M_hash_code_ext(__from);
      }

      void
      _M_store_code(__node_value_type& __to, __hash_code __code) const
      {
 if constexpr (__hash_cached::value)
   __to._M_hash_code = __code;
      }
#pragma GCC diagnostic pop




      __node_base_ptr
      _M_find_before_node(size_type, const key_type&, __hash_code) const;

      template<typename _Kt>
 __node_base_ptr
 _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const;



      struct __location_type
      {

 explicit operator bool() const noexcept
 { return static_cast<bool>(_M_before); }


 explicit operator iterator() const noexcept
 { return iterator(_M_node()); }


 explicit operator const_iterator() const noexcept
 { return const_iterator(_M_node()); }


 __node_ptr _M_node() const
 {
   if (_M_before)
     return static_cast<__node_ptr>(_M_before->_M_nxt);
   return __node_ptr();
 }

 __node_base_ptr _M_before{};
 __hash_code _M_hash_code{};
 size_type _M_bucket_index = size_type(-1);
      };
# 902 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/hashtable.h" 3
      __location_type
      _M_locate(const key_type& __k) const;

      __node_ptr
      _M_find_node(size_type __bkt, const key_type& __key,
     __hash_code __c) const
      {
 if (__node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c))
   return static_cast<__node_ptr>(__before_n->_M_nxt);
 return nullptr;
      }

      template<typename _Kt>
 __node_ptr
 _M_find_node_tr(size_type __bkt, const _Kt& __key,
   __hash_code __c) const
 {
   if (auto __before_n = _M_find_before_node_tr(__bkt, __key, __c))
     return static_cast<__node_ptr>(__before_n->_M_nxt);
   return nullptr;
 }


      void
      _M_insert_bucket_begin(size_type __bkt, __node_ptr __node)
      {
 if (_M_buckets[__bkt])
   {


     __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
     _M_buckets[__bkt]->_M_nxt = __node;
   }
 else
   {



     __node->_M_nxt = _M_before_begin._M_nxt;
     _M_before_begin._M_nxt = __node;

     if (__node->_M_nxt)


       _M_buckets[_M_bucket_index(*__node->_M_next())] = __node;

     _M_buckets[__bkt] = &_M_before_begin;
   }
      }


      void
      _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n,
        size_type __next_bkt)
      {
 if (!__next_n)
   _M_buckets[__bkt] = nullptr;
 else if (__next_bkt != __bkt)
   {
     _M_buckets[__next_bkt] = _M_buckets[__bkt];
     _M_buckets[__bkt] = nullptr;
   }
      }


      __node_base_ptr
      _M_get_previous_node(size_type __bkt, __node_ptr __n);

      pair<__node_ptr, __hash_code>
      _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const;







      iterator
      _M_insert_unique_node(size_type __bkt, __hash_code,
       __node_ptr __n, size_type __n_elt = 1);



      iterator
      _M_insert_multi_node(__node_ptr __hint,
      __hash_code __code, __node_ptr __n);

      template<typename... _Args>
 std::pair<iterator, bool>
 _M_emplace_uniq(_Args&&... __args);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++14-extensions"
      template<typename _Arg, typename _DArg = __remove_cvref_t<_Arg>,
        typename = _ExtractKey>
 static constexpr bool __is_key_type = false;

      template<typename _Arg>
 static constexpr bool
 __is_key_type<_Arg, key_type, __detail::_Identity> = true;

      template<typename _Arg, typename _Arg1, typename _Arg2>
 static constexpr bool
 __is_key_type<_Arg, pair<_Arg1, _Arg2>, __detail::_Select1st>
   = is_same<__remove_cvref_t<_Arg1>, key_type>::value;
#pragma GCC diagnostic pop

      template<typename... _Args>
 iterator
 _M_emplace_multi(const_iterator, _Args&&... __args);

      iterator
      _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n);

      template<typename _InputIterator>
 void
 _M_insert_range_multi(_InputIterator __first, _InputIterator __last);

    public:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"

      template<typename... _Args>
 __ireturn_type
 emplace(_Args&&... __args)
 {
   if constexpr (__unique_keys::value)
     return _M_emplace_uniq(std::forward<_Args>(__args)...);
   else
     return _M_emplace_multi(cend(), std::forward<_Args>(__args)...);
 }

      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __hint, _Args&&... __args)
 {
   if constexpr (__unique_keys::value)
     return _M_emplace_uniq(std::forward<_Args>(__args)...).first;
   else
     return _M_emplace_multi(__hint, std::forward<_Args>(__args)...);
 }


      __ireturn_type
      insert(const value_type& __v)
      {
 if constexpr (__unique_keys::value)
   return _M_emplace_uniq(__v);
 else
   return _M_emplace_multi(cend(), __v);
      }

      iterator
      insert(const_iterator __hint, const value_type& __v)
      {
 if constexpr (__unique_keys::value)
   return _M_emplace_uniq(__v).first;
 else
   return _M_emplace_multi(__hint, __v);
      }

      __ireturn_type
      insert(value_type&& __v)
      {
 if constexpr (__unique_keys::value)
   return _M_emplace_uniq(std::move(__v));
 else
   return _M_emplace_multi(cend(), std::move(__v));
      }

      iterator
      insert(const_iterator __hint, value_type&& __v)
      {
 if constexpr (__unique_keys::value)
   return _M_emplace_uniq(std::move(__v)).first;
 else
   return _M_emplace_multi(__hint, std::move(__v));
      }


      template<typename _KType, typename... _Args>
 std::pair<iterator, bool>
 try_emplace(const_iterator, _KType&& __k, _Args&&... __args)
 {
   __hash_code __code;
   size_type __bkt;
   if (auto __loc = _M_locate(__k))
     return { iterator(__loc), false };
   else
     {
       __code = __loc._M_hash_code;
       __bkt = __loc._M_bucket_index;
     }

   _Scoped_node __node {
     this,
     std::piecewise_construct,
     std::forward_as_tuple(std::forward<_KType>(__k)),
     std::forward_as_tuple(std::forward<_Args>(__args)...)
   };
   auto __it = _M_insert_unique_node(__bkt, __code, __node._M_node);
   __node._M_node = nullptr;
   return { __it, true };
 }


      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }

      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 {
   if constexpr (__unique_keys::value)
     for (; __first != __last; ++__first)
       _M_emplace_uniq(*__first);
   else
     return _M_insert_range_multi(__first, __last);
 }


      template<typename _Pair,
        typename = _Require<__not_<is_same<_Key, _Value>>,
       is_constructible<value_type, _Pair&&>>>
 __ireturn_type
 insert(_Pair&& __v)
 {
   if constexpr (__unique_keys::value)
     return _M_emplace_uniq(std::forward<_Pair>(__v));
   else
     return _M_emplace_multi(cend(), std::forward<_Pair>(__v));
 }


      template<typename _Pair,
        typename = _Require<__not_<is_same<_Key, _Value>>,
       is_constructible<value_type, _Pair&&>>>
 iterator
 insert(const_iterator __hint, _Pair&& __v)
 {
   if constexpr (__unique_keys::value)
     return _M_emplace_uniq(std::forward<_Pair>(__v));
   else
     return _M_emplace_multi(__hint, std::forward<_Pair>(__v));
 }
#pragma GCC diagnostic pop


      iterator
      erase(const_iterator);



      iterator
      erase(iterator __it)
      { return erase(const_iterator(__it)); }

      size_type
      erase(const key_type& __k);

      iterator
      erase(const_iterator, const_iterator);

      void
      clear() noexcept;



      void rehash(size_type __bkt_count);






      insert_return_type
      _M_reinsert_node(node_type&& __nh)
      {
 insert_return_type __ret;
 if (__nh.empty())
   __ret.position = end();
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

     if (auto __loc = _M_locate(__nh._M_key()))
       {
  __ret.node = std::move(__nh);
  __ret.position = iterator(__loc);
  __ret.inserted = false;
       }
     else
       {
  auto __code = __loc._M_hash_code;
  auto __bkt = __loc._M_bucket_index;
  __ret.position
       = _M_insert_unique_node(__bkt, __code, __nh._M_ptr);
  __ret.inserted = true;
  __nh.release();
       }
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
      {
 if (__nh.empty())
   return end();

 do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

 const key_type& __k = __nh._M_key();
 auto __code = this->_M_hash_code(__k);
 auto __ret
   = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr);
 __nh.release();
 return __ret;
      }

    private:
      node_type
      _M_extract_node(size_t __bkt, __node_base_ptr __prev_n)
      {
 __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
 if (__prev_n == _M_buckets[__bkt])
   _M_remove_bucket_begin(__bkt, __n->_M_next(),
      __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0);
 else if (__n->_M_nxt)
   {
     size_type __next_bkt = _M_bucket_index(*__n->_M_next());
     if (__next_bkt != __bkt)
       _M_buckets[__next_bkt] = __prev_n;
   }

 __prev_n->_M_nxt = __n->_M_nxt;
 __n->_M_nxt = nullptr;
 --_M_element_count;
 return { __n, this->_M_node_allocator() };
      }





      template<typename _H2>
 __hash_code
 _M_src_hash_code(const _H2&, const __node_value_type& __src_n) const
 {
   if constexpr (__and_<__hash_cached,
   is_same<_H2, _Hash>, is_empty<_Hash>>::value)

     return __src_n._M_hash_code;
   else
     return this->_M_hash_code(_ExtractKey{}(__src_n._M_v()));
 }

    public:

      node_type
      extract(const_iterator __pos)
      {
 size_t __bkt = _M_bucket_index(*__pos._M_cur);
 return _M_extract_node(__bkt,
          _M_get_previous_node(__bkt, __pos._M_cur));
      }


      node_type
      extract(const _Key& __k)
      {
 node_type __nh;
 __hash_code __code = this->_M_hash_code(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code))
   __nh = _M_extract_node(__bkt, __prev_node);
 return __nh;
      }


      void
      _M_merge_unique(_Hashtable& __src)
      {
 do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

 using _PTr = pointer_traits<__node_base_ptr>;

 auto __n_elt = __src.size();
 size_type __first = 1;


 auto __prev = _PTr::pointer_to(__src._M_before_begin);
 while (__n_elt--)
   {
     const auto __next = __prev->_M_nxt;
     const auto& __node = static_cast<__node_type&>(*__next);
     const key_type& __k = _ExtractKey{}(__node._M_v());
     const auto __loc = _M_locate(__k);
     if (__loc)
       {
  __prev = __next;
  continue;
       }

     auto __src_bkt = __src._M_bucket_index(__node);
     auto __nh = __src._M_extract_node(__src_bkt, __prev);
     _M_insert_unique_node(__loc._M_bucket_index, __loc._M_hash_code,
      __nh._M_ptr, __first * __n_elt + 1);
     __nh.release();
     __first = 0;
   }
      }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_unique(_Compatible_Hashtable& __src)
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

   auto __n_elt = __src.size();
   size_type __first = 1;


   for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)
     {
       --__n_elt;
       auto __pos = __i++;
       const key_type& __k = _ExtractKey{}(*__pos);
       const auto __loc = _M_locate(__k);
       if (__loc)
  continue;

       auto __nh = __src.extract(__pos);
       _M_insert_unique_node(__loc._M_bucket_index,
        __loc._M_hash_code, __nh._M_ptr,
        __first * __n_elt + 1);
       __nh.release();
       __first = 0;
     }
 }


      void
      _M_merge_multi(_Hashtable& __src)
      {
 do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

 if (__src.size() == 0) [[__unlikely__]]
   return;

 using _PTr = pointer_traits<__node_base_ptr>;

 __node_ptr __hint = nullptr;
 this->reserve(size() + __src.size());


 auto __prev = _PTr::pointer_to(__src._M_before_begin);
 do
   {
     const auto& __node = static_cast<__node_type&>(*__prev->_M_nxt);

     auto __code = _M_hash_code_ext(__node);

     size_type __src_bkt = __src._M_bucket_index(__node);
     auto __nh = __src._M_extract_node(__src_bkt, __prev);
     __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur;
     __nh.release();
   }
 while (__prev->_M_nxt != nullptr);
      }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_multi(_Compatible_Hashtable& __src)
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) std::__glibcxx_assert_fail(); } while (false);

   __node_ptr __hint = nullptr;
   this->reserve(size() + __src.size());


   for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)
     {
       auto __pos = __i++;
       __hash_code __code
  = _M_src_hash_code(__src.hash_function(), *__pos._M_cur);
       auto __nh = __src.extract(__pos);
       __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur;
       __nh.release();
     }
 }


      bool
      _M_equal(const _Hashtable& __other) const;

    private:

      void _M_rehash(size_type __bkt_count, true_type __uks);


      void _M_rehash(size_type __bkt_count, false_type __uks);
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(size_type __bkt_count_hint,
        const _Hash& __h, const _Equal& __eq, const allocator_type& __a)
    : _Hashtable(__h, __eq, __a)
    {
      auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);
      if (__bkt_count > _M_bucket_count)
 {
   _M_buckets = _M_allocate_buckets(__bkt_count);
   _M_bucket_count = __bkt_count;
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator>
      inline
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _Hashtable(_InputIterator __f, _InputIterator __l,
   size_type __bkt_count_hint,
   const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a, true_type )
      : _Hashtable(__bkt_count_hint, __h, __eq, __a)
      { this->insert(__f, __l); }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator>
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _Hashtable(_InputIterator __f, _InputIterator __l,
   size_type __bkt_count_hint,
   const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a, false_type __uks)
      : _Hashtable(__h, __eq, __a)
      {
 auto __nb_elems = __detail::__distance_fw(__f, __l);
 auto __bkt_count =
   _M_rehash_policy._M_next_bkt(
     std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
       __bkt_count_hint));

 if (__bkt_count > _M_bucket_count)
   {
     _M_buckets = _M_allocate_buckets(__bkt_count);
     _M_bucket_count = __bkt_count;
   }

 for (; __f != __l; ++__f)
   _M_emplace_multi(cend(), *__f);
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    operator=(const _Hashtable& __ht)
    -> _Hashtable&
    {
      if (&__ht == this)
 return *this;

      if (__node_alloc_traits::_S_propagate_on_copy_assign())
 {
   auto& __this_alloc = this->_M_node_allocator();
   auto& __that_alloc = __ht._M_node_allocator();
   if (!__node_alloc_traits::_S_always_equal()
       && __this_alloc != __that_alloc)
     {

       this->_M_deallocate_nodes(_M_begin());
       _M_before_begin._M_nxt = nullptr;
       _M_deallocate_buckets();
       _M_buckets = nullptr;
       std::__alloc_on_copy(__this_alloc, __that_alloc);
       __hashtable_base::operator=(__ht);
       _M_bucket_count = __ht._M_bucket_count;
       _M_element_count = __ht._M_element_count;
       _M_rehash_policy = __ht._M_rehash_policy;

       struct _Guard
       {
  ~_Guard() { if (_M_ht) _M_ht->_M_reset(); }
  _Hashtable* _M_ht;
       };


       _Guard __guard{this};
       _M_assign(__ht);
       __guard._M_ht = nullptr;
       return *this;
     }
   std::__alloc_on_copy(__this_alloc, __that_alloc);
 }


      _M_assign_elements(__ht);
      return *this;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Ht>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_assign_elements(_Ht&& __ht)
      {
 using __reuse_or_alloc_node_gen_t =
   __detail::_ReuseOrAllocNode<__node_alloc_type>;

 __buckets_ptr __former_buckets = nullptr;
 std::size_t __former_bucket_count = _M_bucket_count;
 __rehash_guard_t __rehash_guard(_M_rehash_policy);

 if (_M_bucket_count != __ht._M_bucket_count)
   {
     __former_buckets = _M_buckets;
     _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
     _M_bucket_count = __ht._M_bucket_count;
   }
 else
   std::fill_n(_M_buckets, _M_bucket_count, nullptr);

 try
   {
     __hashtable_base::operator=(std::forward<_Ht>(__ht));
     _M_element_count = __ht._M_element_count;
     _M_rehash_policy = __ht._M_rehash_policy;
     __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
     _M_before_begin._M_nxt = nullptr;
     _M_assign(std::forward<_Ht>(__ht), __roan);
     if (__former_buckets)
       _M_deallocate_buckets(__former_buckets, __former_bucket_count);
     __rehash_guard._M_guarded_obj = nullptr;
   }
 catch(...)
   {
     if (__former_buckets)
       {

  _M_deallocate_buckets();
  _M_buckets = __former_buckets;
  _M_bucket_count = __former_bucket_count;
       }
     std::fill_n(_M_buckets, _M_bucket_count, nullptr);
     throw;
   }
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Ht, typename _NodeGenerator>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_assign(_Ht&& __ht, _NodeGenerator& __node_gen)
      {
 struct _Guard
 {
   ~_Guard()
   {
     if (_M_ht)
       {
  _M_ht->clear();
  if (_M_dealloc_buckets)
    _M_ht->_M_deallocate_buckets();
       }
   }
   _Hashtable* _M_ht = nullptr;
   bool _M_dealloc_buckets = false;
 };
 _Guard __guard;

 if (!_M_buckets)
   {
     _M_buckets = _M_allocate_buckets(_M_bucket_count);
     __guard._M_dealloc_buckets = true;
   }

 if (!__ht._M_before_begin._M_nxt)
   return;

 __guard._M_ht = this;

 using _FromVal = __conditional_t<is_lvalue_reference<_Ht>::value,
      const value_type&, value_type&&>;



 __node_ptr __ht_n = __ht._M_begin();
 __node_ptr __this_n
   = __node_gen(static_cast<_FromVal>(__ht_n->_M_v()));
 _M_copy_code(*__this_n, *__ht_n);
 _M_update_bbegin(__this_n);


 __node_ptr __prev_n = __this_n;
 for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
   {
     __this_n = __node_gen(static_cast<_FromVal>(__ht_n->_M_v()));
     __prev_n->_M_nxt = __this_n;
     _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;
   }
 __guard._M_ht = nullptr;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_reset() noexcept
    {
      _M_rehash_policy._M_reset();
      _M_bucket_count = 1;
      _M_single_bucket = nullptr;
      _M_buckets = &_M_single_bucket;
      _M_before_begin._M_nxt = nullptr;
      _M_element_count = 0;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, true_type)
    {
      if (__builtin_expect(std::__addressof(__ht) == this, false))
 return;

      this->_M_deallocate_nodes(_M_begin());
      _M_deallocate_buckets();
      __hashtable_base::operator=(std::move(__ht));
      _M_rehash_policy = __ht._M_rehash_policy;
      if (!__ht._M_uses_single_bucket())
 _M_buckets = __ht._M_buckets;
      else
 {
   _M_buckets = &_M_single_bucket;
   _M_single_bucket = __ht._M_single_bucket;
 }

      _M_bucket_count = __ht._M_bucket_count;
      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
      _M_element_count = __ht._M_element_count;
      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());


      _M_update_bbegin();
      __ht._M_reset();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, false_type)
    {
      if (__ht._M_node_allocator() == this->_M_node_allocator())
 _M_move_assign(std::move(__ht), true_type{});
      else
 {

   _M_assign_elements(std::move(__ht));
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    inline
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(const _Hashtable& __ht)
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(
 __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
      __enable_default_ctor(__ht),
      _M_buckets(nullptr),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      _M_assign(__ht);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
        true_type )
    noexcept(_S_nothrow_move())
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(std::move(__a)),
      __enable_default_ctor(__ht),
      _M_buckets(__ht._M_buckets),
      _M_bucket_count(__ht._M_bucket_count),
      _M_before_begin(__ht._M_before_begin._M_nxt),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {

      if (__ht._M_uses_single_bucket())
 {
   _M_buckets = &_M_single_bucket;
   _M_single_bucket = __ht._M_single_bucket;
 }


      _M_update_bbegin();

      __ht._M_reset();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    inline
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(__node_alloc_type(__a)),
      __enable_default_ctor(__ht),
      _M_buckets(),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      _M_assign(__ht);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
        false_type )
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(std::move(__a)),
      __enable_default_ctor(__ht),
      _M_buckets(nullptr),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      if (__ht._M_node_allocator() == this->_M_node_allocator())
 {
   if (__ht._M_uses_single_bucket())
     {
       _M_buckets = &_M_single_bucket;
       _M_single_bucket = __ht._M_single_bucket;
     }
   else
     _M_buckets = __ht._M_buckets;



   _M_update_bbegin(__ht._M_begin());

   __ht._M_reset();
 }
      else
 {
   using _Fwd_Ht = __conditional_t<
     __move_if_noexcept_cond<value_type>::value,
     const _Hashtable&, _Hashtable&&>;
   _M_assign(std::forward<_Fwd_Ht>(__ht));
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    ~_Hashtable() noexcept
    {





      static_assert(noexcept(declval<const __hash_code_base_access&>()
   ._M_bucket_index(declval<const __node_value_type&>(),
      (std::size_t)0)),
      "Cache the hash code or qualify your functors involved"
      " in hash code and bucket index computation with noexcept");

      this->_M_deallocate_nodes(_M_begin());
      _M_deallocate_buckets();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    swap(_Hashtable& __x)
    noexcept(__and_<__is_nothrow_swappable<_Hash>,
   __is_nothrow_swappable<_Equal>>::value)
    {
      using std::swap;
      swap(__hash_code_base::_M_hash._M_obj,
    __x.__hash_code_base::_M_hash._M_obj);
      swap(__hashtable_base::_M_equal._M_obj,
    __x.__hashtable_base::_M_equal._M_obj);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      if constexpr (__node_alloc_traits::propagate_on_container_swap::value)
 swap(this->_M_node_allocator(), __x._M_node_allocator());
#pragma GCC diagnostic pop

      std::swap(_M_rehash_policy, __x._M_rehash_policy);


      if (this->_M_uses_single_bucket())
 {
   if (!__x._M_uses_single_bucket())
     {
       _M_buckets = __x._M_buckets;
       __x._M_buckets = &__x._M_single_bucket;
     }
 }
      else if (__x._M_uses_single_bucket())
 {
   __x._M_buckets = _M_buckets;
   _M_buckets = &_M_single_bucket;
 }
      else
 std::swap(_M_buckets, __x._M_buckets);

      std::swap(_M_bucket_count, __x._M_bucket_count);
      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
      std::swap(_M_element_count, __x._M_element_count);
      std::swap(_M_single_bucket, __x._M_single_bucket);



      _M_update_bbegin();
      __x._M_update_bbegin();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    find(const key_type& __k)
    -> iterator
    { return iterator(_M_locate(__k)); }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    find(const key_type& __k) const
    -> const_iterator
    { return const_iterator(_M_locate(__k)); }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_tr(const _Kt& __k)
      -> iterator
      {
 if (size() <= __small_size_threshold())
   {
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       if (this->_M_key_equals_tr(__k, *__n))
  return iterator(__n);
     return end();
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 return iterator(_M_find_node_tr(__bkt, __k, __code));
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_tr(const _Kt& __k) const
      -> const_iterator
      {
 if (size() <= __small_size_threshold())
   {
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       if (this->_M_key_equals_tr(__k, *__n))
  return const_iterator(__n);
     return end();
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 return const_iterator(_M_find_node_tr(__bkt, __k, __code));
      }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    count(const key_type& __k) const
    -> size_type
    {
      auto __it = find(__k);
      if (!__it._M_cur)
 return 0;

      if (__unique_keys::value)
 return 1;

      size_type __result = 1;
      for (auto __ref = __it++;
    __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur);
    ++__it)
 ++__result;

      return __result;
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_count_tr(const _Kt& __k) const
      -> size_type
      {
 if (size() <= __small_size_threshold())
   {
     size_type __result = 0;
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      ++__result;
      continue;
    }

  if (__result)
    break;
       }

     return __result;
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 if (!__n)
   return 0;

 iterator __it(__n);
 size_type __result = 1;
 for (++__it;
      __it._M_cur && this->_M_equals_tr(__k, __code, *__it._M_cur);
      ++__it)
   ++__result;

 return __result;
      }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k)
    -> pair<iterator, iterator>
    {
      auto __ite = find(__k);
      if (!__ite._M_cur)
 return { __ite, __ite };

      auto __beg = __ite++;
      if (__unique_keys::value)
 return { __beg, __ite };

      while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur))
 ++__ite;

      return { __beg, __ite };
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k) const
    -> pair<const_iterator, const_iterator>
    {
      auto __ite = find(__k);
      if (!__ite._M_cur)
 return { __ite, __ite };

      auto __beg = __ite++;
      if (__unique_keys::value)
 return { __beg, __ite };

      while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur))
 ++__ite;

      return { __beg, __ite };
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_equal_range_tr(const _Kt& __k)
      -> pair<iterator, iterator>
      {
 if (size() <= __small_size_threshold())
   {
     __node_ptr __n, __beg = nullptr;
     for (__n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      if (!__beg)
        __beg = __n;
      continue;
    }

  if (__beg)
    break;
       }

     return { iterator(__beg), iterator(__n) };
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 iterator __ite(__n);
 if (!__n)
   return { __ite, __ite };

 auto __beg = __ite++;
 while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur))
   ++__ite;

 return { __beg, __ite };
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_equal_range_tr(const _Kt& __k) const
      -> pair<const_iterator, const_iterator>
      {
 if (size() <= __small_size_threshold())
   {
     __node_ptr __n, __beg = nullptr;
     for (__n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      if (!__beg)
        __beg = __n;
      continue;
    }

  if (__beg)
    break;
       }

     return { const_iterator(__beg), const_iterator(__n) };
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 const_iterator __ite(__n);
 if (!__n)
   return { __ite, __ite };

 auto __beg = __ite++;
 while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur))
   ++__ite;

 return { __beg, __ite };
      }




  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_find_before_node(size_type __bkt, const key_type& __k,
   __hash_code __code) const
    -> __node_base_ptr
    {
      __node_base_ptr __prev_p = _M_buckets[__bkt];
      if (!__prev_p)
 return nullptr;

      for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);;
    __p = __p->_M_next())
 {
   if (this->_M_equals(__k, __code, *__p))
     return __prev_p;

   if (__builtin_expect (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt, 0))
     break;
   __prev_p = __p;
 }

      return nullptr;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_before_node_tr(size_type __bkt, const _Kt& __k,
        __hash_code __code) const
      -> __node_base_ptr
      {
 __node_base_ptr __prev_p = _M_buckets[__bkt];
 if (!__prev_p)
   return nullptr;

 for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);;
      __p = __p->_M_next())
   {
     if (this->_M_equals_tr(__k, __code, *__p))
       return __prev_p;

     if (__builtin_expect (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt, 0))
       break;
     __prev_p = __p;
   }

 return nullptr;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    inline auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_locate(const key_type& __k) const
    -> __location_type
    {
      __location_type __loc;
      const auto __size = size();

      if (__size <= __small_size_threshold())
 {
   __loc._M_before = pointer_traits<__node_base_ptr>::
        pointer_to(const_cast<__node_base&>(_M_before_begin));
   while (__loc._M_before->_M_nxt)
     {
       if (this->_M_key_equals(__k, *__loc._M_node()))
  return __loc;
       __loc._M_before = __loc._M_before->_M_nxt;
     }
   __loc._M_before = nullptr;
 }

      __loc._M_hash_code = this->_M_hash_code(__k);
      __loc._M_bucket_index = _M_bucket_index(__loc._M_hash_code);

      if (__size > __small_size_threshold())
 __loc._M_before = _M_find_before_node(__loc._M_bucket_index, __k,
           __loc._M_hash_code);

      return __loc;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_get_previous_node(size_type __bkt, __node_ptr __n)
    -> __node_base_ptr
    {
      __node_base_ptr __prev_n = _M_buckets[__bkt];
      while (__prev_n->_M_nxt != __n)
 __prev_n = __prev_n->_M_nxt;
      return __prev_n;
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_emplace_uniq(_Args&&... __args)
      -> pair<iterator, bool>
      {
 const key_type* __kp = nullptr;

 if constexpr (sizeof...(_Args) == 1)
   {
     if constexpr (__is_key_type<_Args...>)
       {
  const auto& __key = _ExtractKey{}(__args...);
  __kp = std::__addressof(__key);
       }
   }
 else if constexpr (sizeof...(_Args) == 2)
   {
     if constexpr (__is_key_type<pair<const _Args&...>>)
       {
  pair<const _Args&...> __refs(__args...);
  const auto& __key = _ExtractKey{}(__refs);
  __kp = std::__addressof(__key);
       }
   }

 _Scoped_node __node { __node_ptr(), this };
 __hash_code __code = 0;
 size_type __bkt = 0;

 if (__kp == nullptr)
   {

     __node._M_node
    = this->_M_allocate_node(std::forward<_Args>(__args)...);
     const key_type& __key = _ExtractKey{}(__node._M_node->_M_v());
     __kp = std::__addressof(__key);
   }

 if (auto __loc = _M_locate(*__kp))

   return { iterator(__loc), false };
 else
   {
     __code = __loc._M_hash_code;
     __bkt = __loc._M_bucket_index;
   }

 if (!__node._M_node)
   __node._M_node
  = this->_M_allocate_node(std::forward<_Args>(__args)...);


 auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node);
 __node._M_node = nullptr;
 return { __pos, true };
      }
#pragma GCC diagnostic pop

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_emplace_multi(const_iterator __hint, _Args&&... __args)
      -> iterator
      {

 _Scoped_node __node { this, std::forward<_Args>(__args)... };
 const key_type& __k = _ExtractKey{}(__node._M_node->_M_v());

 auto __res = this->_M_compute_hash_code(__hint._M_cur, __k);
 auto __pos
   = _M_insert_multi_node(__res.first, __res.second, __node._M_node);
 __node._M_node = nullptr;
 return __pos;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
   void
  _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
      _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
  _M_rehash_insert(size_type __n)
  {
    using __pair_type = std::pair<bool, std::size_t>;
    if (__n == 0)
      return;

    __rehash_guard_t __rehash_guard(_M_rehash_policy);
    __pair_type __do_rehash
      = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n);

    if (__do_rehash.first)
      _M_rehash(__do_rehash.second, false_type{});

    __rehash_guard._M_guarded_obj = nullptr;
  }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_insert_range_multi(_InputIterator __first, _InputIterator __last)
      {
 _M_rehash_insert(__detail::__distance_fw(__first, __last));
 for (; __first != __last; ++__first)
   _M_emplace_multi(cend(), *__first);
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const
    -> pair<__node_ptr, __hash_code>
    {
      if (size() <= __small_size_threshold())
 {
   if (__hint)
     {
       for (auto __it = __hint; __it; __it = __it->_M_next())
  if (this->_M_key_equals(__k, *__it))
    return { __it, this->_M_hash_code(*__it) };
     }

   for (auto __it = _M_begin(); __it != __hint; __it = __it->_M_next())
     if (this->_M_key_equals(__k, *__it))
       return { __it, this->_M_hash_code(*__it) };

   __hint = nullptr;
 }

      return { __hint, this->_M_hash_code(__k) };
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_insert_unique_node(size_type __bkt, __hash_code __code,
     __node_ptr __node, size_type __n_elt)
    -> iterator
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
       __n_elt);

      if (__do_rehash.first)
 {
   _M_rehash(__do_rehash.second, true_type{});
   __bkt = _M_bucket_index(__code);
 }

      __rehash_guard._M_guarded_obj = nullptr;
      _M_store_code(*__node, __code);


      _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_insert_multi_node(__node_ptr __hint,
    __hash_code __code, __node_ptr __node)
    -> iterator
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);

      if (__do_rehash.first)
 _M_rehash(__do_rehash.second, false_type{});

      __rehash_guard._M_guarded_obj = nullptr;
      _M_store_code(*__node, __code);
      const key_type& __k = _ExtractKey{}(__node->_M_v());
      size_type __bkt = _M_bucket_index(__code);



      __node_base_ptr __prev
 = __builtin_expect(__hint != nullptr, false)
   && this->_M_equals(__k, __code, *__hint)
     ? __hint
     : _M_find_before_node(__bkt, __k, __code);

      if (__prev)
 {

   __node->_M_nxt = __prev->_M_nxt;
   __prev->_M_nxt = __node;
   if (__builtin_expect(__prev == __hint, false))


     if (__node->_M_nxt
  && !this->_M_equals(__k, __code, *__node->_M_next()))
       {
  size_type __next_bkt = _M_bucket_index(*__node->_M_next());
  if (__next_bkt != __bkt)
    _M_buckets[__next_bkt] = __node;
       }
 }
      else



 _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    erase(const_iterator __it)
    -> iterator
    {
      __node_ptr __n = __it._M_cur;
      std::size_t __bkt = _M_bucket_index(*__n);




      __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n);
      return _M_erase(__bkt, __prev_n, __n);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n)
    -> iterator
    {
      if (__prev_n == _M_buckets[__bkt])
 _M_remove_bucket_begin(__bkt, __n->_M_next(),
   __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0);
      else if (__n->_M_nxt)
 {
   size_type __next_bkt = _M_bucket_index(*__n->_M_next());
   if (__next_bkt != __bkt)
     _M_buckets[__next_bkt] = __prev_n;
 }

      __prev_n->_M_nxt = __n->_M_nxt;
      iterator __result(__n->_M_next());
      this->_M_deallocate_node(__n);
      --_M_element_count;

      return __result;
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    erase(const key_type& __k)
    -> size_type
    {
      auto __loc = _M_locate(__k);
      if (!__loc)
 return 0;

      __node_base_ptr __prev_n = __loc._M_before;
      __node_ptr __n = __loc._M_node();
      auto __bkt = __loc._M_bucket_index;
      if (__bkt == size_type(-1))
 __bkt = _M_bucket_index(*__n);

      if constexpr (__unique_keys::value)
 {
   _M_erase(__bkt, __prev_n, __n);
   return 1;
 }
      else
 {






   __node_ptr __n_last = __n->_M_next();
   while (__n_last && this->_M_node_equals(*__n, *__n_last))
     __n_last = __n_last->_M_next();

   std::size_t __n_last_bkt
     = __n_last ? _M_bucket_index(*__n_last) : __bkt;


   size_type __result = 0;
   do
     {
       __node_ptr __p = __n->_M_next();
       this->_M_deallocate_node(__n);
       __n = __p;
       ++__result;
     }
   while (__n != __n_last);

   _M_element_count -= __result;
   if (__prev_n == _M_buckets[__bkt])
     _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
   else if (__n_last_bkt != __bkt)
     _M_buckets[__n_last_bkt] = __prev_n;
   __prev_n->_M_nxt = __n_last;
   return __result;
 }
    }
#pragma GCC diagnostic pop

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    erase(const_iterator __first, const_iterator __last)
    -> iterator
    {
      __node_ptr __n = __first._M_cur;
      __node_ptr __last_n = __last._M_cur;
      if (__n == __last_n)
 return iterator(__n);

      std::size_t __bkt = _M_bucket_index(*__n);

      __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n);
      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
      std::size_t __n_bkt = __bkt;
      for (;;)
 {
   do
     {
       __node_ptr __tmp = __n;
       __n = __n->_M_next();
       this->_M_deallocate_node(__tmp);
       --_M_element_count;
       if (!__n)
  break;
       __n_bkt = _M_bucket_index(*__n);
     }
   while (__n != __last_n && __n_bkt == __bkt);
   if (__is_bucket_begin)
     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
   if (__n == __last_n)
     break;
   __is_bucket_begin = true;
   __bkt = __n_bkt;
 }

      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
 _M_buckets[__n_bkt] = __prev_n;
      __prev_n->_M_nxt = __n;
      return iterator(__n);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    clear() noexcept
    {
      this->_M_deallocate_nodes(_M_begin());
      std::fill_n(_M_buckets, _M_bucket_count, nullptr);
      _M_element_count = 0;
      _M_before_begin._M_nxt = nullptr;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    rehash(size_type __bkt_count)
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      __bkt_count
 = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
     __bkt_count);
      __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count);

      if (__bkt_count != _M_bucket_count)
 {
   _M_rehash(__bkt_count, __unique_keys{});
   __rehash_guard._M_guarded_obj = nullptr;
 }
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_rehash(size_type __bkt_count, true_type )
    {
      __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);
      __node_ptr __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      while (__p)
 {
   __node_ptr __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(*__p, __bkt_count);
   if (!__new_buckets[__bkt])
     {
       __p->_M_nxt = _M_before_begin._M_nxt;
       _M_before_begin._M_nxt = __p;
       __new_buckets[__bkt] = &_M_before_begin;
       if (__p->_M_nxt)
  __new_buckets[__bbegin_bkt] = __p;
       __bbegin_bkt = __bkt;
     }
   else
     {
       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
       __new_buckets[__bkt]->_M_nxt = __p;
     }

   __p = __next;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }



  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_rehash(size_type __bkt_count, false_type )
    {
      __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);
      __node_ptr __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      std::size_t __prev_bkt = 0;
      __node_ptr __prev_p = nullptr;
      bool __check_bucket = false;

      while (__p)
 {
   __node_ptr __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(*__p, __bkt_count);

   if (__prev_p && __prev_bkt == __bkt)
     {



       __p->_M_nxt = __prev_p->_M_nxt;
       __prev_p->_M_nxt = __p;






       __check_bucket = true;
     }
   else
     {
       if (__check_bucket)
  {


    if (__prev_p->_M_nxt)
      {
        std::size_t __next_bkt
   = __hash_code_base::_M_bucket_index(
     *__prev_p->_M_next(), __bkt_count);
        if (__next_bkt != __prev_bkt)
   __new_buckets[__next_bkt] = __prev_p;
      }
    __check_bucket = false;
  }

       if (!__new_buckets[__bkt])
  {
    __p->_M_nxt = _M_before_begin._M_nxt;
    _M_before_begin._M_nxt = __p;
    __new_buckets[__bkt] = &_M_before_begin;
    if (__p->_M_nxt)
      __new_buckets[__bbegin_bkt] = __p;
    __bbegin_bkt = __bkt;
  }
       else
  {
    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
    __new_buckets[__bkt]->_M_nxt = __p;
  }
     }
   __prev_p = __p;
   __prev_bkt = __bkt;
   __p = __next;
 }

      if (__check_bucket && __prev_p->_M_nxt)
 {
   std::size_t __next_bkt
     = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(),
      __bkt_count);
   if (__next_bkt != __prev_bkt)
     __new_buckets[__next_bkt] = __prev_p;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"




  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    bool
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_equal(const _Hashtable& __other) const
    {
      if (size() != __other.size())
 return false;

      if constexpr (__unique_keys::value)
 for (auto __x_n = _M_begin(); __x_n; __x_n = __x_n->_M_next())
   {
     std::size_t __ybkt = __other._M_bucket_index_ext(*__x_n);
     auto __prev_n = __other._M_buckets[__ybkt];
     if (!__prev_n)
       return false;

     for (__node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);;
   __n = __n->_M_next())
       {
  if (__n->_M_v() == __x_n->_M_v())
    break;

  if (!__n->_M_nxt
      || __other._M_bucket_index(*__n->_M_next()) != __ybkt)
    return false;
       }
   }
      else
 for (auto __x_n = _M_begin(); __x_n;)
   {
     std::size_t __x_count = 1;
     auto __x_n_end = __x_n->_M_next();
     for (; __x_n_end
     && key_eq()(_ExtractKey{}(__x_n->_M_v()),
          _ExtractKey{}(__x_n_end->_M_v()));
   __x_n_end = __x_n_end->_M_next())
       ++__x_count;

     std::size_t __ybkt = __other._M_bucket_index_ext(*__x_n);
     auto __y_prev_n = __other._M_buckets[__ybkt];
     if (!__y_prev_n)
       return false;

     __node_ptr __y_n = static_cast<__node_ptr>(__y_prev_n->_M_nxt);
     for (;;)
       {
  if (key_eq()(_ExtractKey{}(__y_n->_M_v()),
        _ExtractKey{}(__x_n->_M_v())))
    break;

  auto __y_ref_n = __y_n;
  for (__y_n = __y_n->_M_next(); __y_n; __y_n = __y_n->_M_next())
    if (!__other._M_node_equals(*__y_ref_n, *__y_n))
      break;

  if (!__y_n || __other._M_bucket_index(*__y_n) != __ybkt)
    return false;
       }

     auto __y_n_end = __y_n;
     for (; __y_n_end; __y_n_end = __y_n_end->_M_next())
       if (--__x_count == 0)
  break;

     if (__x_count != 0)
       return false;

     const_iterator __itx(__x_n), __itx_end(__x_n_end);
     const_iterator __ity(__y_n);
     if (!std::is_permutation(__itx, __itx_end, __ity))
       return false;

     __x_n = __x_n_end;
   }

      return true;
    }
#pragma GCC diagnostic pop


  template<typename, typename, typename> class _Hash_merge_helper { };




  template<typename _Hash>
    using _RequireNotAllocatorOrIntegral
      = __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>;




}

#pragma GCC diagnostic pop
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{




  template<bool _Cache>
    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
                                        _Alloc, __detail::_Select1st,
            _Pred, _Hash,
            __detail::_Mod_range_hashing,
            __detail::_Default_ranged_hash,
            __detail::_Prime_rehash_policy, _Tr>;


  template<bool _Cache>
    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
      _Alloc, __detail::_Select1st,
      _Pred, _Hash,
      __detail::_Mod_range_hashing,
      __detail::_Default_ranged_hash,
      __detail::_Prime_rehash_policy, _Tr>;

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    class unordered_multimap;
# 108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 160 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 181 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n = 0,
        const hasher& __hf = hasher(),
        const key_equal& __eql = key_equal(),
        const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_map(const unordered_map&) = default;


      unordered_map(unordered_map&&) = default;





      explicit
      unordered_map(const allocator_type& __a)
 : _M_h(__a)
      { }






      unordered_map(const unordered_map& __umap,
      const allocator_type& __a)
      : _M_h(__umap._M_h, __a)
      { }






      unordered_map(unordered_map&& __umap,
      const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) )
      : _M_h(std::move(__umap._M_h), __a)
      { }
# 237 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      unordered_map&
      operator=(const unordered_map&) = default;


      unordered_map&
      operator=(unordered_map&&) = default;
# 342 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 439 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_h.extract(__pos);
      }


      node_type
      extract(const key_type& __key)
      { return _M_h.extract(__key); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_h._M_reinsert_node(std::move(__nh)); }


      iterator
      insert(const_iterator, node_type&& __nh)
      { return _M_h._M_reinsert_node(std::move(__nh)).position; }
# 523 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(const key_type& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(cend(), __k, std::forward<_Args>(__args)...);
 }


      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(key_type&& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(cend(), std::move(__k),
      std::forward<_Args>(__args)...);
 }
# 567 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, const key_type& __k,
      _Args&&... __args)
 {
   return _M_h.try_emplace(__hint, __k,
      std::forward<_Args>(__args)...).first;
 }


      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(__hint, std::move(__k),
      std::forward<_Args>(__args)...).first;
 }
# 604 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 643 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 668 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 680 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 723 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(const key_type& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(cend(), __k,
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret;
 }


      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(key_type&& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(cend(), std::move(__k),
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret;
 }
# 772 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint, const key_type& __k,
    _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret.first;
 }


      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(__hint, std::move(__k),
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret.first;
 }
# 810 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 832 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 850 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 874 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
 {
   if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>)
     if (std::__addressof(__source) == this) [[__unlikely__]]
       return;

   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)
 {
   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)
 {
   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(); }
# 945 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 978 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 997 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 1018 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }
# 1056 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)]; }
# 1073 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1144 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1155 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1192 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1203 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;
# 1362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1413 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 1434 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_multimap(_InputIterator __first, _InputIterator __last,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_multimap(const unordered_multimap&) = default;


      unordered_multimap(unordered_multimap&&) = default;





      explicit
      unordered_multimap(const allocator_type& __a)
      : _M_h(__a)
      { }






      unordered_multimap(const unordered_multimap& __ummap,
    const allocator_type& __a)
      : _M_h(__ummap._M_h, __a)
      { }






      unordered_multimap(unordered_multimap&& __ummap,
    const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) )
      : _M_h(std::move(__ummap._M_h), __a)
      { }
# 1490 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 1577 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      unordered_multimap&
      operator=(const unordered_multimap&) = default;


      unordered_multimap&
      operator=(unordered_multimap&&) = default;
# 1595 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1687 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1714 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...); }
# 1729 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1763 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1788 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1801 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 1833 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_h.extract(__pos);
      }


      node_type
      extract(const key_type& __key)
      { return _M_h.extract(__key); }


      iterator
      insert(node_type&& __nh)
      { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }
# 1870 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1891 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1910 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1934 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
 {
   if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>)
     if (std::__addressof(__source) == this) [[__unlikely__]]
       return;

   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)
 {
   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)
 {
   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(); }
# 2008 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 2037 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 2056 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 2075 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }






      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }







      local_iterator
      begin(size_type __n)
      { return _M_h.begin(__n); }
# 2147 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2162 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 2173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 2210 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 2221 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;
# 2360 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
  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); }
# 2388 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }
# 2406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_map.h" 3
  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };


  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };



}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_map" 2 3
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_map" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_map" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_map
 = std::unordered_map<_Key, _Tp, _Hash, _Pred,
        polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_multimap
 = std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
      polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
    typename _Alloc, typename _Predicate>
    inline typename unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
    typename _Alloc, typename _Predicate>
    inline typename unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>::
      size_type
    erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/array" 1 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/array" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/array" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, size_t _Nm>
    struct __array_traits
    {
      using _Type = _Tp[_Nm];
      using _Is_swappable = __is_swappable<_Tp>;
      using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>;
    };

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {

     struct _Type
     {

       __attribute__((__always_inline__,__noreturn__))
       _Tp& operator[](size_t) const noexcept { __builtin_trap(); }


       __attribute__((__always_inline__))
       constexpr explicit operator _Tp*() const noexcept { return nullptr; }
     };

     using _Is_swappable = true_type;
     using _Is_nothrow_swappable = true_type;
   };
# 101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/array" 3
  template<typename _Tp, std::size_t _Nm>
    struct array
    {
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef value_type* iterator;
      typedef const value_type* const_iterator;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;


      typename __array_traits<_Tp, _Nm>::_Type _M_elems;




      constexpr void
      fill(const value_type& __u)
      { std::fill_n(begin(), size(), __u); }

      constexpr void
      swap(array& __other)
      noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value)
      { std::swap_ranges(begin(), end(), __other.begin()); }


      [[__gnu__::__const__, __nodiscard__]]
      constexpr iterator
      begin() noexcept
      { return iterator(data()); }

      [[__nodiscard__]]
      constexpr const_iterator
      begin() const noexcept
      { return const_iterator(data()); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr iterator
      end() noexcept
      { return iterator(data() + _Nm); }

      [[__nodiscard__]]
      constexpr const_iterator
      end() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      [[__nodiscard__]]
      constexpr const_iterator
      cbegin() const noexcept
      { return const_iterator(data()); }

      [[__nodiscard__]]
      constexpr const_iterator
      cend() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr size_type
      size() const noexcept { return _Nm; }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr size_type
      max_size() const noexcept { return _Nm; }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr bool
      empty() const noexcept { return size() == 0; }


      [[__nodiscard__]]
      constexpr reference
      operator[](size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return _M_elems[__n];
      }

      [[__nodiscard__]]
      constexpr const_reference
      operator[](size_type __n) const noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);

 return _M_elems[__n];
      }

      constexpr reference
      at(size_type __n)
      {
 if (__n >= _Nm)
   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),

     __n, _Nm);
 return _M_elems[__n];
      }

      constexpr const_reference
      at(size_type __n) const
      {


 return __n < _Nm ? _M_elems[__n]
   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),

        __n, _Nm),
      _M_elems[__n]);
      }

      [[__nodiscard__]]
      constexpr reference
      front() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return _M_elems[(size_type)0];
      }

      [[__nodiscard__]]
      constexpr const_reference
      front() const noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);

 return _M_elems[(size_type)0];
      }

      [[__nodiscard__]]
      constexpr reference
      back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return _M_elems[_Nm - 1];
      }

      [[__nodiscard__]]
      constexpr const_reference
      back() const noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);

 return _M_elems[_Nm - 1];
      }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr pointer
      data() noexcept
      { return static_cast<pointer>(_M_elems); }

      [[__nodiscard__]]
      constexpr const_pointer
      data() const noexcept
      { return static_cast<const_pointer>(_M_elems); }
    };


  template<typename _Tp, typename... _Up>
    array(_Tp, _Up...)
      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
        1 + sizeof...(_Up)>;



  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr
    inline bool
    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return std::__equal_aux1(__one.begin(), __one.end(), __two.begin()); }


  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr __detail::__synth3way_t<_Tp>
    operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
    {
      if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value)
 if (!std::__is_constant_evaluated())
   {
     constexpr size_t __n = _Nm * sizeof(_Tp);
     return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0;
   }

      for (size_t __i = 0; __i < _Nm; ++__i)
 {
   auto __c = __detail::__synth3way(__a[__i], __b[__i]);
   if (__c != 0)
     return __c;
 }
      return strong_ordering::equal;
    }
# 370 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/array" 3
  template<typename _Tp, std::size_t _Nm>
    constexpr
    inline


    __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value>



    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
    noexcept(noexcept(__one.swap(__two)))
    { __one.swap(__two); }


  template<typename _Tp, std::size_t _Nm>
    __enable_if_t<!__array_traits<_Tp, _Nm>::_Is_swappable::value>
    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;


  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&
    get(array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __arr._M_elems[_Int];
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&&
    get(array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&
    get(const array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __arr._M_elems[_Int];
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }


  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&__a)[_Nm])
    noexcept(is_nothrow_constructible_v<_Tp, _Tp&>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_constructible_v<_Tp, _Tp&>);
      if constexpr (is_constructible_v<_Tp, _Tp&>)
 {
   if constexpr (is_trivially_copyable_v<_Tp>
     && is_trivially_default_constructible_v<_Tp>
     && is_copy_assignable_v<_Tp>)
     {
       array<remove_cv_t<_Tp>, _Nm> __arr;
       if (!__is_constant_evaluated() && _Nm != 0)
  __builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
       else
  for (size_t __i = 0; __i < _Nm; ++__i)
    __arr._M_elems[__i] = __a[__i];
       return __arr;
     }
   else
     return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
       return array<remove_cv_t<_Tp>, _Nm>{{ __a[_Idx]... }};
     }(make_index_sequence<_Nm>{});
 }
      else
 __builtin_unreachable();
    }

  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&&__a)[_Nm])
    noexcept(is_nothrow_move_constructible_v<_Tp>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_move_constructible_v<_Tp>);
      if constexpr (is_move_constructible_v<_Tp>)
 {
   if constexpr (is_trivially_copyable_v<_Tp>
     && is_trivially_default_constructible_v<_Tp>
     && is_copy_assignable_v<_Tp>)
     {
       array<remove_cv_t<_Tp>, _Nm> __arr;
       if (!__is_constant_evaluated() && _Nm != 0)
  __builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
       else
  for (size_t __i = 0; __i < _Nm; ++__i)
    __arr._M_elems[__i] = __a[__i];
       return __arr;
     }
   else
     return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
       return array<remove_cv_t<_Tp>, _Nm>{{ std::move(__a[_Idx])... }};
     }(make_index_sequence<_Nm>{});
 }
      else
 __builtin_unreachable();
    }





  template<typename _Tp, size_t _Nm>
    struct tuple_size<array<_Tp, _Nm>>
    : public integral_constant<size_t, _Nm> { };


  template<size_t _Ind, typename _Tp, size_t _Nm>
    struct tuple_element<_Ind, array<_Tp, _Nm>>
    {
      static_assert(_Ind < _Nm, "array index is in range");
      using type = _Tp;
    };


  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<array<_Tp, _Nm>> = _Nm;

  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<const array<_Tp, _Nm>> = _Nm;


  template<typename _Tp, size_t _Nm>
    struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
    { };


}
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 2 3
# 90 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 91 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{






  template<int _Num> struct _Placeholder { };
# 117 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Callable, typename... _Args>
    inline constexpr invoke_result_t<_Callable, _Args...>
    invoke(_Callable&& __fn, _Args&&... __args)
    noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
    {
      return std::__invoke(std::forward<_Callable>(__fn),
      std::forward<_Args>(__args)...);
    }
# 150 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _MemFunPtr,
    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
    class _Mem_fn_base
    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
    {
      using _Traits = _Mem_fn_traits<_MemFunPtr>;

      using _Arity = typename _Traits::__arity;
      using _Varargs = typename _Traits::__vararg;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemFunPtr _M_pmf;

    public:

      using result_type = typename _Traits::__result_type;

      explicit constexpr
      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }

      template<typename... _Args>
 constexpr
 auto
 operator()(_Args&&... __args) const
 noexcept(noexcept(
       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
 -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
 { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
    };


  template<typename _MemObjPtr>
    class _Mem_fn_base<_MemObjPtr, false>
    {
      using _Arity = integral_constant<size_t, 0>;
      using _Varargs = false_type;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemObjPtr _M_pm;

    public:
      explicit constexpr
      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }

      template<typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __obj) const
 noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
 -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
 { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
    };

  template<typename _MemberPointer>
    struct _Mem_fn;

  template<typename _Res, typename _Class>
    struct _Mem_fn<_Res _Class::*>
    : _Mem_fn_base<_Res _Class::*>
    {
      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
    };
# 243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Tp, typename _Class>
    constexpr
    inline _Mem_fn<_Tp _Class::*>
    mem_fn(_Tp _Class::* __pm) noexcept
    {
      return _Mem_fn<_Tp _Class::*>(__pm);
    }
# 262 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Tp>
    struct is_bind_expression
    : public false_type { };
# 274 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Tp>
    struct is_placeholder
    : public integral_constant<int, 0>
    { };


  template <typename _Tp> inline constexpr bool is_bind_expression_v
    = is_bind_expression<_Tp>::value;
  template <typename _Tp> inline constexpr int is_placeholder_v
    = is_placeholder<_Tp>::value;







  namespace placeholders
  {
# 303 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
    inline const _Placeholder<1> _1;
    inline const _Placeholder<2> _2;
    inline const _Placeholder<3> _3;
    inline const _Placeholder<4> _4;
    inline const _Placeholder<5> _5;
    inline const _Placeholder<6> _6;
    inline const _Placeholder<7> _7;
    inline const _Placeholder<8> _8;
    inline const _Placeholder<9> _9;
    inline const _Placeholder<10> _10;
    inline const _Placeholder<11> _11;
    inline const _Placeholder<12> _12;
    inline const _Placeholder<13> _13;
    inline const _Placeholder<14> _14;
    inline const _Placeholder<15> _15;
    inline const _Placeholder<16> _16;
    inline const _Placeholder<17> _17;
    inline const _Placeholder<18> _18;
    inline const _Placeholder<19> _19;
    inline const _Placeholder<20> _20;
    inline const _Placeholder<21> _21;
    inline const _Placeholder<22> _22;
    inline const _Placeholder<23> _23;
    inline const _Placeholder<24> _24;
    inline const _Placeholder<25> _25;
    inline const _Placeholder<26> _26;
    inline const _Placeholder<27> _27;
    inline const _Placeholder<28> _28;
    inline const _Placeholder<29> _29;


  }







  template<int _Num>
    struct is_placeholder<_Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };

  template<int _Num>
    struct is_placeholder<const _Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };




  template<std::size_t __i, typename _Tuple>
    using _Safe_tuple_element_t
      = typename enable_if<(__i < tuple_size<_Tuple>::value),
      tuple_element<__i, _Tuple>>::type::type;
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Arg,
    bool _IsBindExp = is_bind_expression<_Arg>::value,
    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
    class _Mu;






  template<typename _Tp>
    class _Mu<reference_wrapper<_Tp>, false, false>
    {
    public:




      template<typename _CVRef, typename _Tuple>
 constexpr
 _Tp&
 operator()(_CVRef& __arg, _Tuple&) const volatile
 { return __arg.get(); }
    };







  template<typename _Arg>
    class _Mu<_Arg, true, false>
    {
    public:
      template<typename _CVArg, typename... _Args>
 constexpr
 auto
 operator()(_CVArg& __arg,
     tuple<_Args...>& __tuple) const volatile
 -> decltype(__arg(declval<_Args>()...))
 {

   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
     _Indexes;
   return this->__call(__arg, __tuple, _Indexes());
 }

    private:


      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
 constexpr
 auto
 __call(_CVArg& __arg, tuple<_Args...>& __tuple,
        const _Index_tuple<_Indexes...>&) const volatile
 -> decltype(__arg(declval<_Args>()...))
 {
   return __arg(std::get<_Indexes>(std::move(__tuple))...);
 }
    };






  template<typename _Arg>
    class _Mu<_Arg, false, true>
    {
    public:
      template<typename _Tuple>
 constexpr
 _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
 operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
 {
   return
     ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
 }
    };






  template<typename _Arg>
    class _Mu<_Arg, false, false>
    {
    public:
      template<typename _CVArg, typename _Tuple>
 constexpr
 _CVArg&&
 operator()(_CVArg&& __arg, _Tuple&) const volatile
 { return std::forward<_CVArg>(__arg); }
    };


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(const volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
# 496 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Signature>
    class _Bind;

   template<typename _Functor, typename... _Bound_args>
    class _Bind<_Functor(_Bound_args...)>
    : public _Weak_result_type<_Functor>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Result, typename... _Args, std::size_t... _Indexes>
 constexpr
 _Result
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
       );
 }


      template<typename _Result, typename... _Args, std::size_t... _Indexes>
 constexpr
 _Result
 __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
       );
 }
# 555 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
      template<typename _BoundArg, typename _CallArgs>
 using _Mu_type = decltype(
     _Mu<typename remove_cv<_BoundArg>::type>()(
       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );

      template<typename _Fn, typename _CallArgs, typename... _BArgs>
 using _Res_type_impl
   = __invoke_result_t<_Fn&, _Mu_type<_BArgs, _CallArgs>&&...>;

      template<typename _CallArgs>
 using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;

      template<typename _CallArgs>
 using __dependent = typename
   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;

      template<typename _CallArgs, template<class> class __cv_quals>
 using _Res_type_cv = _Res_type_impl<
   typename __cv_quals<__dependent<_CallArgs>>::type,
   _CallArgs,
   typename __cv_quals<_Bound_args>::type...>;

     public:
      template<typename... _Args>
 explicit constexpr
 _Bind(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 explicit constexpr
 _Bind(_Functor&& __f, _Args&&... __args)
 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      _Bind(const _Bind&) = default;
      _Bind(_Bind&&) = default;


      template<typename... _Args,
        typename _Result = _Res_type<tuple<_Args...>>>
 constexpr
 _Result
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args,
        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
 constexpr
 _Result
 operator()(_Args&&... __args) const
 {
   return this->__call_c<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
# 642 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
    };


  template<typename _Result, typename _Signature>
    class _Bind_result;

  template<typename _Result, typename _Functor, typename... _Bound_args>
    class _Bind_result<_Result, _Functor(_Bound_args...)>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Res, typename... _Args, std::size_t... _Indexes>
 constexpr
 _Res
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (std::get<_Indexes>(_M_bound_args), __args)...);
 }


      template<typename _Res, typename... _Args, std::size_t... _Indexes>
 constexpr
 _Res
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (std::get<_Indexes>(_M_bound_args), __args)...);
 }
# 698 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
    public:
      typedef _Result result_type;

      template<typename... _Args>
 explicit constexpr
 _Bind_result(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 explicit constexpr
 _Bind_result(_Functor&& __f, _Args&&... __args)
 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      _Bind_result(const _Bind_result&) = default;
      _Bind_result(_Bind_result&&) = default;


      template<typename... _Args>
 constexpr
 result_type
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args>
 constexpr
 result_type
 operator()(_Args&&... __args) const
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
# 761 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
      template<typename... _Args>
 void operator()(_Args&&...) const volatile = delete;

    };
# 773 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Signature>
    struct is_bind_expression<_Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<volatile _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const volatile _Bind<_Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<_Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
    : public true_type { };

  template<typename _Func, typename... _BoundArgs>
    struct _Bind_check_arity { };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args..., ...), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Tp, typename _Class, typename... _BoundArgs>
    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
    {
      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
      static_assert(_Varargs::value
      ? sizeof...(_BoundArgs) >= _Arity::value + 1
      : sizeof...(_BoundArgs) == _Arity::value + 1,
      "Wrong number of arguments for pointer-to-member");
    };




  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;

  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
    struct _Bind_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __func_type;
      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
    };




  template<typename _Func, typename... _BoundArgs>
    struct _Bind_helper<true, _Func, _BoundArgs...>
    { };






  template<typename _Func, typename... _BoundArgs>
    inline constexpr typename
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
       std::forward<_BoundArgs>(__args)...);
    }

  template<typename _Result, typename _Func, typename... _BoundArgs>
    struct _Bindres_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __functor_type;
      typedef _Bind_result<_Result,
      __functor_type(typename decay<_BoundArgs>::type...)>
 type;
    };






  template<typename _Result, typename _Func, typename... _BoundArgs>
    inline constexpr
    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
       std::forward<_BoundArgs>(__args)...);
    }



  template<typename _Fd, typename... _BoundArgs>
    struct _Bind_front
    {
      static_assert(is_move_constructible_v<_Fd>);
      static_assert((is_move_constructible_v<_BoundArgs> && ...));



      template<typename _Fn, typename... _Args>
 explicit constexpr
 _Bind_front(int, _Fn&& __fn, _Args&&... __args)
 noexcept(__and_<is_nothrow_constructible<_Fd, _Fn>,
   is_nothrow_constructible<_BoundArgs, _Args>...>::value)
 : _M_fd(std::forward<_Fn>(__fn)),
   _M_bound_args(std::forward<_Args>(__args)...)
 { static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); }
# 953 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
      template<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<_Fd&, _BoundArgs&..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) &
 noexcept(is_nothrow_invocable_v<_Fd&, _BoundArgs&..., _CallArgs...>)
 {
   return _S_call(*this, _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<const _Fd&, const _BoundArgs&..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) const &
 noexcept(is_nothrow_invocable_v<const _Fd&, const _BoundArgs&...,
     _CallArgs...>)
 {
   return _S_call(*this, _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<_Fd, _BoundArgs..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) &&
 noexcept(is_nothrow_invocable_v<_Fd, _BoundArgs..., _CallArgs...>)
 {
   return _S_call(std::move(*this), _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<const _Fd, const _BoundArgs..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) const &&
 noexcept(is_nothrow_invocable_v<const _Fd, const _BoundArgs...,
     _CallArgs...>)
 {
   return _S_call(std::move(*this), _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) & = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) const & = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) && = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) const && = delete;


    private:
      using _BoundIndices = index_sequence_for<_BoundArgs...>;

      template<typename _Tp, size_t... _Ind, typename... _CallArgs>
 static constexpr
 decltype(auto)
 _S_call(_Tp&& __g, index_sequence<_Ind...>, _CallArgs&&... __call_args)
 {
   return std::invoke(std::forward<_Tp>(__g)._M_fd,
       std::get<_Ind>(std::forward<_Tp>(__g)._M_bound_args)...,
       std::forward<_CallArgs>(__call_args)...);
 }

      [[no_unique_address]] _Fd _M_fd;
      [[no_unique_address]] std::tuple<_BoundArgs...> _M_bound_args;
    };

  template<typename _Fn, typename... _Args>
    using _Bind_front_t = _Bind_front<decay_t<_Fn>, decay_t<_Args>...>;
# 1041 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Fn, typename... _Args>
    constexpr _Bind_front_t<_Fn, _Args...>
    bind_front(_Fn&& __fn, _Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Bind_front_t<_Fn, _Args...>,
     int, _Fn, _Args...>)
    {
      return _Bind_front_t<_Fn, _Args...>(0, std::forward<_Fn>(__fn),
       std::forward<_Args>(__args)...);
    }
# 1123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1163 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn &, _Args...>::value>> constexpr decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); } template<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn &, _Args...>::value>> void operator()(_Args&&... __args) & = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn const &, _Args...>::value>> constexpr decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); } template<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn const &, _Args...>::value>> void operator()(_Args&&... __args) const & = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn &&, _Args...>::value>> constexpr decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); } template<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn &&, _Args...>::value>> void operator()(_Args&&... __args) && = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn const &&, _Args...>::value>> constexpr decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); } template<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn const &&, _Args...>::value>> void operator()(_Args&&... __args) const && = delete;


    private:
      _Fn _M_fn;
    };

  template<typename _Tp, typename _Pred>
    struct __is_byte_like : false_type { };

  template<typename _Tp>
    struct __is_byte_like<_Tp, equal_to<_Tp>>
    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };

  template<typename _Tp>
    struct __is_byte_like<_Tp, equal_to<void>>
    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };



  enum class byte : unsigned char;

  template<>
    struct __is_byte_like<byte, equal_to<byte>>
    : true_type { };

  template<>
    struct __is_byte_like<byte, equal_to<void>>
    : true_type { };
# 1211 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/functional" 3
  template<typename _Fn>
    constexpr
    inline auto
    not_fn(_Fn&& __fn)
    noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
    {
      return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
    }





  template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
    class default_searcher
    {
    public:
      constexpr
      default_searcher(_ForwardIterator1 __pat_first,
         _ForwardIterator1 __pat_last,
         _BinaryPredicate __pred = _BinaryPredicate())
      : _M_m(__pat_first, __pat_last, std::move(__pred))
      { }

      template<typename _ForwardIterator2>
 constexpr
 pair<_ForwardIterator2, _ForwardIterator2>
 operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
 {
   _ForwardIterator2 __first_ret =
     std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m),
   std::get<2>(_M_m));
   auto __ret = std::make_pair(__first_ret, __first_ret);
   if (__ret.first != __last)
     std::advance(__ret.second, std::distance(std::get<0>(_M_m),
           std::get<1>(_M_m)));
   return __ret;
 }

    private:
      tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
    };



  template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
    struct __boyer_moore_map_base
    {
      template<typename _RAIter>
 __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
          _Hash&& __hf, _Pred&& __pred)
 : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
 {
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
 }

      using __diff_type = _Tp;

      __diff_type
      _M_lookup(_Key __key, __diff_type __not_found) const
      {
 auto __iter = _M_bad_char.find(__key);
 if (__iter == _M_bad_char.end())
   return __not_found;
 return __iter->second;
      }

      _Pred
      _M_pred() const { return _M_bad_char.key_eq(); }

      std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
    };

  template<typename _Tp, size_t _Len, typename _Pred>
    struct __boyer_moore_array_base
    {
      template<typename _RAIter, typename _Unused>
 __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
     _Unused&&, _Pred&& __pred)
 : _M_bad_char{ array<_Tp, _Len>{}, std::move(__pred) }
 {
   std::get<0>(_M_bad_char).fill(__patlen);
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       {
  auto __ch = __pat[__i];
  using _UCh = make_unsigned_t<decltype(__ch)>;
  auto __uch = static_cast<_UCh>(__ch);
  std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
       }
 }

      using __diff_type = _Tp;

      template<typename _Key>
 __diff_type
 _M_lookup(_Key __key, __diff_type __not_found) const
 {
   auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
   if (__ukey >= _Len)
     return __not_found;
   return std::get<0>(_M_bad_char)[__ukey];
 }

      const _Pred&
      _M_pred() const { return std::get<1>(_M_bad_char); }

      tuple<array<_Tp, _Len>, _Pred> _M_bad_char;
    };



  template<typename _RAIter, typename _Hash, typename _Pred,
           typename _Val = typename iterator_traits<_RAIter>::value_type,
    typename _Diff = typename iterator_traits<_RAIter>::difference_type>
    using __boyer_moore_base_t
      = __conditional_t<__is_byte_like<_Val, _Pred>::value,
   __boyer_moore_array_base<_Diff, 256, _Pred>,
   __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
      _Hash __hf = _Hash(),
      _BinaryPredicate __pred = _BinaryPredicate());

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const;

    private:
      bool
      _M_is_prefix(_RAIter __word, __diff_type __len,
     __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __suffixlen = __len - __pos;
 for (__diff_type __i = 0; __i < __suffixlen; ++__i)
   if (!__pred(__word[__i], __word[__pos + __i]))
     return false;
 return true;
      }

      __diff_type
      _M_suffix_length(_RAIter __word, __diff_type __len,
         __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __i = 0;
 while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
        && __i < __pos)
   {
     ++__i;
   }
 return __i;
      }

      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
      std::vector<__diff_type> _M_good_suffix;
    };

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_horspool_searcher(_RAIter __pat,
        _RAIter __pat_end,
        _Hash __hf = _Hash(),
        _BinaryPredicate __pred
        = _BinaryPredicate())
      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
 _M_pat(__pat), _M_pat_end(__pat_end)
      { }

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const
 {
   const auto& __pred = this->_M_pred();
   auto __patlen = _M_pat_end - _M_pat;
   if (__patlen == 0)
     return std::make_pair(__first, __first);
   auto __len = __last - __first;
   while (__len >= __patlen)
     {
       for (auto __scan = __patlen - 1;
     __pred(__first[__scan], _M_pat[__scan]); --__scan)
  if (__scan == 0)
    return std::make_pair(__first, __first + __patlen);
       auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
       __len -= __shift;
       __first += __shift;
     }
   return std::make_pair(__last, __last);
 }

    private:
      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
    };

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
    _Hash __hf, _BinaryPredicate __pred)
    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
    {
      auto __patlen = __pat_end - __pat;
      if (__patlen == 0)
 return;
      __diff_type __last_prefix = __patlen - 1;
      for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
 {
   if (_M_is_prefix(__pat, __patlen, __p + 1))
     __last_prefix = __p + 1;
   _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
 }
      for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
 {
   auto __slen = _M_suffix_length(__pat, __patlen, __p);
   auto __pos = __patlen - 1 - __slen;
   if (!__pred(__pat[__p - __slen], __pat[__pos]))
     _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
 }
    }

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
  template<typename _RandomAccessIterator2>
    pair<_RandomAccessIterator2, _RandomAccessIterator2>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    operator()(_RandomAccessIterator2 __first,
        _RandomAccessIterator2 __last) const
    {
      auto __patlen = _M_pat_end - _M_pat;
      if (__patlen == 0)
 return std::make_pair(__first, __first);
      const auto& __pred = this->_M_pred();
      __diff_type __i = __patlen - 1;
      auto __stringlen = __last - __first;
      while (__i < __stringlen)
 {
   __diff_type __j = __patlen - 1;
   while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
     {
       --__i;
       --__j;
     }
   if (__j < 0)
     {
       const auto __match = __first + __i + 1;
       return std::make_pair(__match, __match + __patlen);
     }
   __i += std::max(_M_bad_char_shift(__first[__i]),
     _M_good_suffix[__j]);
 }
      return std::make_pair(__last, __last);
    }







}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_hash.hpp" 2 3

namespace std
{
  template <typename T>
  struct hash<boost::optional<T> >
  {
    typedef std::size_t result_type;
    typedef boost::optional<T> argument_type;

    constexpr result_type operator()(const argument_type& arg) const {
      return arg ? std::hash<T>()(*arg) : result_type();
    }
  };

  template <typename T>
  struct hash<boost::optional<T&> >
  {
    typedef std::size_t result_type;
    typedef boost::optional<T&> argument_type;

    constexpr result_type operator()(const argument_type& arg) const {
      return arg ? std::hash<T>()(*arg) : result_type();
    }
  };
}
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_utility.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_utility.hpp" 3
namespace boost {
namespace optional_detail {


template <class T>
inline constexpr T&& forward(typename boost::remove_reference<T>::type& t) noexcept
{
  return static_cast<T&&>(t);
}

template <class T>
inline constexpr T&& forward(typename boost::remove_reference<T>::type&& t) noexcept
{
  static_assert(!boost::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue.");
  return static_cast<T&&>(t);
}

template <class T>
inline constexpr typename boost::remove_reference<T>::type&& move(T&& t) noexcept
{
  return static_cast<typename boost::remove_reference<T>::type&&>(t);
}

}
}
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3

namespace boost { namespace optional_detail {

template <typename T>
struct optional_value_type
{
};

template <typename U>
struct optional_value_type< ::boost::optional<U> >
{
  typedef U type;
};

template <typename T>
T declval();




template <typename F, typename Ref, typename Rslt = decltype(declval<F>()(declval<Ref>()))>
struct result_of
{
  typedef Rslt type;
};

template <typename F, typename Ref, typename Rslt = typename optional_value_type<typename result_of<F, Ref>::type>::type>
struct result_value_type
{
  typedef Rslt type;
};



}}

namespace boost {

namespace optional_ns {


struct in_place_init_t
{
  struct init_tag{};
  constexpr explicit in_place_init_t(init_tag){}
};
inline constexpr in_place_init_t in_place_init ((in_place_init_t::init_tag()));


struct in_place_init_if_t
{
  struct init_tag{};
  constexpr explicit in_place_init_if_t(init_tag){}
};
inline constexpr in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag()));

}

using optional_ns::in_place_init_t;
using optional_ns::in_place_init;
using optional_ns::in_place_init_if_t;
using optional_ns::in_place_init_if;

namespace optional_detail {

struct init_value_tag {};

struct optional_tag {};


template<class T>
class optional_base : public optional_tag
{
  private :

    typedef aligned_storage<T> storage_type ;
    typedef optional_base<T> this_type ;

  protected :

    typedef T value_type ;
    typedef typename boost::remove_const<T>::type unqualified_value_type;

  protected:
    typedef T & reference_type ;
    typedef T const& reference_const_type ;
    typedef T && rval_reference_type ;
    typedef T && reference_type_of_temporary_wrapper ;
    typedef T * pointer_type ;
    typedef T const* pointer_const_type ;
    typedef T const& argument_type ;



    optional_base()
      :
      m_initialized(false) {}



    optional_base ( none_t )
      :
      m_initialized(false) {}



    optional_base ( init_value_tag, argument_type val )
      :
      m_initialized(false)
    {
        construct(val);
    }



    optional_base ( init_value_tag, rval_reference_type val )
      :
      m_initialized(false)
    {
      construct( optional_detail::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(optional_detail::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( optional_detail::move(rhs.get_impl()) );
    }


    template<class Expr, class PtrExpr>
    explicit optional_base ( Expr&& expr, PtrExpr const* tag )
      :
      m_initialized(false)
    {
      construct(optional_detail::forward<Expr>(expr),tag);
    }

    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( optional_detail::move(rhs.get_impl()) );
        else destroy();
      }
      else
      {
        if ( rhs.is_initialized() )
          construct(optional_detail::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( optional_detail::move(val) );
      else construct( optional_detail::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(optional_detail::forward<Expr>(expr),tag);
      else construct(optional_detail::forward<Expr>(expr),tag);
    }



  public :



    void reset() noexcept { destroy(); }


    void reset ( argument_type val ) { assign(val); }




    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
    pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }

    bool is_initialized() const noexcept { return m_initialized ; }

  protected :

    void construct ( argument_type val )
     {
       ::new (m_storage.address()) unqualified_value_type(val) ;
       m_initialized = true ;
     }

    void construct ( rval_reference_type val )
     {
       ::new (m_storage.address()) unqualified_value_type( optional_detail::move(val) ) ;
       m_initialized = true ;
     }




    template<class... Args>
    void construct ( in_place_init_t, Args&&... args )
    {
      ::new (m_storage.address()) unqualified_value_type( optional_detail::forward<Args>(args)... ) ;
      m_initialized = true ;
    }

    template<class... Args>
    void emplace_assign ( Args&&... args )
    {
      destroy();
      construct(in_place_init, optional_detail::forward<Args>(args)...);
    }

    template<class... Args>
    explicit optional_base ( in_place_init_t, Args&&... args )
      :
      m_initialized(false)
    {
      construct(in_place_init, optional_detail::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, optional_detail::forward<Args>(args)...);
    }




    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);
     }







    template<class Expr>
    void construct ( Expr&& expr, void const* )
    {
      new (m_storage.address()) unqualified_value_type(optional_detail::forward<Expr>(expr)) ;
      m_initialized = true ;
    }





    template<class Expr>
    void assign_expr_to_initialized ( Expr&& expr, void const* )
    {
      assign_value( optional_detail::forward<Expr>(expr) );
    }
# 506 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
    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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3
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), m_storage() {}

    tc_optional_base ( none_t )
      :
      m_initialized(false), m_storage() {}

    tc_optional_base ( init_value_tag, argument_type val )
      :
      m_initialized(true), m_storage(val) {}

    tc_optional_base ( bool cond, argument_type val )
      :
      m_initialized(cond), m_storage(val) {}



    template<class Expr, class PtrExpr>
    explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
      :
      m_initialized(false)
    {
      construct(optional_detail::forward<Expr>(expr),tag);
    }





    void assign ( tc_optional_base const& rhs )
    {
      *this = rhs;
    }


    template<class U>
    void assign ( optional<U> const& rhs )
    {
      if ( rhs.is_initialized() )

        m_storage = rhs.get();




      m_initialized = rhs.is_initialized();
    }


    template<class U>
    void assign ( optional<U>&& rhs )
    {
      typedef typename optional<U>::rval_reference_type ref_type;
      if ( rhs.is_initialized() )
        m_storage = static_cast<ref_type>(rhs.get());
      m_initialized = rhs.is_initialized();
    }

    void assign ( argument_type val )
    {
      construct(val);
    }

    void assign ( none_t ) { destroy(); }



    template<class Expr, class ExprPtr>
    void assign_expr ( Expr&& expr, ExprPtr const* tag )
    {
       construct(optional_detail::forward<Expr>(expr),tag);
    }



  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( optional_detail::forward<Args>(args)... ) ;
      m_initialized = true ;
    }

    template<class... Args>
    void emplace_assign ( Args&&... args )
    {
      construct(in_place_init, optional_detail::forward<Args>(args)...);
    }

    template<class... Args>
    explicit tc_optional_base ( in_place_init_t, Args&&... args )
      :
      m_initialized(false)
    {
      construct(in_place_init, optional_detail::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, optional_detail::forward<Args>(args)...);
    }




    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);
     }







    template<class Expr>
    void construct ( Expr&& expr, void const* )
    {
      m_storage = value_type(optional_detail::forward<Expr>(expr)) ;
      m_initialized = true ;
    }





    template<class Expr>
    void assign_expr_to_initialized ( Expr&& expr, void const* )
    {
      assign_value( optional_detail::forward<Expr>(expr) );
    }
# 252 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3
    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 ;
} ;
# 534 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3


template <typename U>
struct is_optional_or_tag
  : boost::conditional< boost::is_base_of<optional_detail::optional_tag, typename boost::decay<U>::type>::value
                     || boost::is_same<typename boost::decay<U>::type, none_t>::value
                     || boost::is_same<typename boost::decay<U>::type, in_place_init_t>::value
                     || boost::is_same<typename boost::decay<U>::type, in_place_init_if_t>::value,
    boost::true_type, boost::false_type>::type
{};

template <typename T, typename U>
struct has_dedicated_constructor
  : boost::disjunction<is_optional_or_tag<U>, boost::is_same<T, typename boost::decay<U>::type> >
{};

template <typename U>
struct is_in_place_factory
  : boost::disjunction< boost::is_base_of<boost::in_place_factory_base, typename boost::decay<U>::type>,
                        boost::is_base_of<boost::typed_in_place_factory_base, typename boost::decay<U>::type> >
{};



template <typename T, typename U>
struct is_factory_or_constructible_to_T
  : boost::disjunction< is_in_place_factory<U>, boost::is_constructible<T, U&&> >
{};

template <typename T, typename U>
struct is_optional_constructible : boost::is_constructible<T, U>
{};
# 585 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
template <typename T, typename U>
struct is_opt_assignable
  : boost::conjunction<boost::is_convertible<U&&, T>, boost::is_assignable<T&, U&&> >
{};
# 598 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
template <typename T, typename U>
struct is_factory_or_opt_assignable_to_T
  : boost::disjunction< is_in_place_factory<U>, is_opt_assignable<T, U> >
{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
struct is_optional_val_init_candidate
  : boost::false_type
{};

template <typename T, typename U>
struct is_optional_val_init_candidate<T, U, false>
  : is_factory_or_constructible_to_T<T, U>
{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
struct is_optional_val_assign_candidate
  : boost::false_type
{};

template <typename T, typename U>
struct is_optional_val_assign_candidate<T, U, false>
  : is_factory_or_opt_assignable_to_T<T, U>
{};

}

namespace optional_config {

template <typename T>
struct optional_uses_direct_storage_for
  : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
                      , boost::true_type, boost::false_type>::type
{};

}
# 645 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
template<class T>
class optional
  : public boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, optional_detail::tc_optional_base<T>, optional_detail::optional_base<T> >::type
{
    typedef typename boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, optional_detail::tc_optional_base<T>, optional_detail::optional_base<T> >::type base ;

  public :

    typedef optional<T> this_type ;

    typedef typename base::value_type value_type ;
    typedef typename base::reference_type reference_type ;
    typedef typename base::reference_const_type reference_const_type ;
    typedef typename base::rval_reference_type rval_reference_type ;
    typedef typename base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;
    typedef typename base::pointer_type pointer_type ;
    typedef typename base::pointer_const_type pointer_const_type ;
    typedef typename base::argument_type argument_type ;



    optional() noexcept : base() {}



    optional( none_t none_ ) noexcept : base(none_) {}



    optional ( argument_type val ) : base(optional_detail::init_value_tag(), val) {}



    optional ( rval_reference_type val ) : base(optional_detail::init_value_tag(), optional_detail::forward<T>(val))
      {}



    optional ( bool cond, argument_type val ) : base(cond,val) {}



    optional ( bool cond, rval_reference_type val ) : base( cond, optional_detail::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( optional_detail::move(rhs.get()) );
    }
# 736 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
  template<class Expr>
  explicit optional ( Expr&& expr,
                      typename boost::enable_if< optional_detail::is_optional_val_init_candidate<T, Expr>, bool>::type = true
  )
    : base(optional_detail::forward<Expr>(expr),boost::addressof(expr))
    {}






    optional ( optional const& ) = default;







    optional ( optional && ) = default;
# 775 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
    template<class Expr>
    typename boost::enable_if<optional_detail::is_optional_val_assign_candidate<T, Expr>, optional&>::type
    operator= ( Expr&& expr )
      {
        this->assign_expr(optional_detail::forward<Expr>(expr),boost::addressof(expr));
        return *this ;
      }






    template<class U>
    optional& operator= ( optional<U> const& rhs )
      {
        this->assign(rhs);
        return *this ;
      }




    template<class U>
    optional& operator= ( optional<U> && rhs )
      {
        this->assign(optional_detail::move(rhs));
        return *this ;
      }





    optional& operator= ( optional const& rhs ) = default;
# 820 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
    optional& operator= ( optional && ) = default;
# 833 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
    template <typename T_>
    typename boost::enable_if<boost::is_same<T, typename boost::decay<T_>::type>, optional&>::type
    operator= ( T_&& val )
      {
        this->assign( optional_detail::forward<T_>(val) ) ;
        return *this ;
      }
# 863 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 3
    optional& operator= ( none_t none_ ) noexcept
      {
        this->assign( none_ ) ;
        return *this ;
      }



    template<class... Args>
    void emplace ( Args&&... args )
    {
      this->emplace_assign( optional_detail::forward<Args>(args)... );
    }

    template<class... Args>
    explicit optional ( in_place_init_t, Args&&... args )
    : base( in_place_init, optional_detail::forward<Args>(args)... )
    {}

    template<class... Args>
    explicit optional ( in_place_init_if_t, bool cond, Args&&... args )
    : base( in_place_init_if, cond, optional_detail::forward<Args>(args)... )
    {}

    void swap( optional & arg )
      noexcept((::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value))
      {

        boost::core::invoke_swap(*this, arg);
      }





    reference_const_type get() const { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp", 898, __extension__ __PRETTY_FUNCTION__)) ; return this->get_impl(); }
    reference_type get() { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp", 899, __extension__ __PRETTY_FUNCTION__)) ; return this->get_impl(); }


    reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }
    reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; }




    pointer_const_type operator->() const { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp", 908, __extension__ __PRETTY_FUNCTION__)) ; return this->get_ptr_impl() ; }
    pointer_type operator->() { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp", 909, __extension__ __PRETTY_FUNCTION__)) ; return this->get_ptr_impl() ; }




    reference_const_type operator *() const& { return this->get() ; }
    reference_type operator *() & { return this->get() ; }


    reference_type_of_temporary_wrapper operator *() && { return optional_detail::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());
      }

    template <class U>
    value_type value_or ( U&& v ) const&
      {
        if (this->is_initialized())
          return get();
        else
          return optional_detail::forward<U>(v);
      }

    template <typename F>
    value_type value_or_eval ( F f ) const&
      {
        if (this->is_initialized())
          return get();
        else
          return f();
      }


    reference_type_of_temporary_wrapper value() &&
      {
        if (this->is_initialized())
          return optional_detail::move(this->get()) ;
        else
          throw_exception(bad_optional_access());
      }

    template <class U>
    value_type value_or ( U&& v ) &&
      {
        if (this->is_initialized())
          return optional_detail::move(get());
        else
          return optional_detail::forward<U>(v);
      }

    template <typename F>
    value_type value_or_eval ( F f ) &&
      {
        if (this->is_initialized())
          return optional_detail::move(get());
        else
          return f();
      }




    template <typename F>
    optional<typename optional_detail::result_of<F, reference_type>::type> map(F f) &
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename optional_detail::result_of<F, reference_const_type>::type> map(F f) const&
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }


    template <typename F>
    optional<typename optional_detail::result_of<F, reference_type_of_temporary_wrapper>::type> map(F f) &&
      {
        if (this->has_value())
          return f(optional_detail::move(this->get()));
        else
          return none;
      }


    template <typename F>
    optional<typename optional_detail::result_value_type<F, reference_type>::type>
    flat_map(F f) &
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
    flat_map(F f) const&
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }


    template <typename F>
    optional<typename optional_detail::result_value_type<F, reference_type_of_temporary_wrapper>::type>
    flat_map(F f) &&
      {
        if (this->has_value())
          return f(optional_detail::move(get()));
        else
          return none;
      }


    bool has_value() const noexcept { return this->is_initialized() ; }

    explicit operator bool() const noexcept { return this->has_value() ; }
} ;


template<class T>
class optional<T&&>
{
  static_assert(sizeof(T) == 0, "Optional rvalue references are illegal.");
} ;

}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp" 3
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 optional_detail::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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp" 3
}


template <class T>
struct is_optional_
{
  static const bool value = false;
};

template <class U>
struct is_optional_< ::boost::optional<U> >
{
  static const bool value = true;
};

template <class T>
struct is_no_optional
{
  static const bool value = !is_optional_<typename boost::decay<T>::type>::value;
};


template <class T, class U>
  struct is_same_decayed
  {
    static const bool value = ::boost::is_same<T, typename ::boost::remove_reference<U>::type>::value
                           || ::boost::is_same<T, const typename ::boost::remove_reference<U>::type>::value;
  };

template <class T, class U>
struct no_unboxing_cond
{
  static const bool value = is_no_optional<U>::value && !is_same_decayed<T, U>::value;
};


}

template <class T>
class optional<T&> : public optional_detail::optional_tag
{
    T* ptr_;

public:
    typedef T& value_type;
    typedef T& reference_type;
    typedef T& reference_const_type;
    typedef T& rval_reference_type;
    typedef T* pointer_type;
    typedef T* pointer_const_type;

    optional() noexcept : ptr_() {}
    optional(none_t) noexcept : ptr_() {}

    template <class U>
        explicit optional(const optional<U&>& rhs) noexcept : ptr_(rhs.get_ptr()) {}
    optional(const optional& rhs) noexcept : ptr_(rhs.get_ptr()) {}


    template <class U>
      explicit optional(U& rhs, typename boost::enable_if_c<detail::is_same_decayed<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) noexcept
      : ptr_(boost::addressof(rhs)) {}

    template <class U>
      optional(U& rhs, typename boost::enable_if_c<detail::is_same_decayed<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) noexcept
      : ptr_(boost::addressof(rhs)) {}

    optional& operator=(const optional& rhs) noexcept { ptr_ = rhs.get_ptr(); return *this; }
    template <class U>
        optional& operator=(const optional<U&>& rhs) noexcept { ptr_ = rhs.get_ptr(); return *this; }
    optional& operator=(none_t) noexcept { ptr_ = 0; return *this; }


    void swap(optional& rhs) noexcept { std::swap(ptr_, rhs.ptr_); }
    T& get() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp", 149, __extension__ __PRETTY_FUNCTION__)); return *ptr_; }

    T* get_ptr() const noexcept { return ptr_; }
    T* operator->() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp", 152, __extension__ __PRETTY_FUNCTION__)); return ptr_; }
    T& operator*() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp", 153, __extension__ __PRETTY_FUNCTION__)); return *ptr_; }

    T& value() const
    {
      if (this->is_initialized())
        return this->get();
      else
        throw_exception(bad_optional_access());
    }

    explicit operator bool() const noexcept { return ptr_ != 0; }

    void reset() noexcept { ptr_ = 0; }

    bool is_initialized() const noexcept { return ptr_ != 0; }
    bool has_value() const noexcept { return ptr_ != 0; }

    template <typename F>
    optional<typename optional_detail::result_of<F, reference_const_type>::type>
    map(F f) const
    {
      if (this->has_value())
        return f(this->get());
      else
        return none;
    }

    template <typename F>
    optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
    flat_map(F f) const
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }



    optional(T&& ) noexcept { detail::prevent_binding_rvalue<T&&>(); }

    template <class R>
        optional(R&& r, typename boost::enable_if<detail::no_unboxing_cond<T, R>, bool>::type = true) noexcept
        : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue<R>(); }

    template <class R>
        optional(bool cond, R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
        : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue<R>(); }

    template <class R>
        typename boost::enable_if<detail::is_no_optional<R>, optional<T&>&>::type
        operator=(R&& r) noexcept { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); return *this; }

    template <class R>
        void emplace(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
        { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }

    template <class R>
      T& get_value_or(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const noexcept
      { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }

    template <class R>
        T& value_or(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const noexcept
        { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }

    template <class R>
      void reset(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
      { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }

    template <class F>
        T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); }
# 268 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_reference_spec.hpp" 3
};

template <class T>
  void swap ( optional<T&>& x, optional<T&>& y) noexcept
{
  x.swap(y);
}

}
# 1062 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3


namespace boost {


template<class T>
inline
optional<typename boost::decay<T>::type> make_optional ( T && v )
{
  return optional<typename boost::decay<T>::type>(optional_detail::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,optional_detail::forward<T>(v));
}




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 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_relops.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_relops.hpp" 3
namespace boost {
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_relops.hpp" 3
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 !y ? false : (!x ? true : (*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 x && (*x == y); }

template<class T>
inline
bool operator < ( optional<T> const& x, T const& y )
{ return (!x) || (*x < 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 y && (x == *y); }

template<class T>
inline
bool operator < ( T const& x, optional<T> const& y )
{ return y && (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&, none_t )
{ return false; }

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 bool(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 ) ; }

}
# 1173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_swap.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_swap.hpp" 3
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::core::invoke_swap(x.get(), y.get());

        if( !hasX )
            y = boost::none ;
        else if( !hasY )
            x = boost::none ;
    }
};
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_swap.hpp" 3
template <>
struct swap_selector<false>
{
    template <class T>
    static void optional_swap ( optional<T>& x, optional<T>& y )

    {
        if (x)
        {
            if (y)
            {
                boost::core::invoke_swap(*x, *y);
            }
            else
            {
                y = optional_detail::move(*x);
                x = boost::none;
            }
        }
        else
        {
            if (y)
            {
                x = optional_detail::move(*y);
                y = boost::none;
            }
        }
    }
};

}



template<class T>
struct optional_swap_should_use_default_constructor : boost::false_type {} ;
# 106 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/detail/optional_swap.hpp" 3
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);
}

}
# 1174 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional/optional.hpp" 2 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/optional.hpp" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/limits.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 1 3
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 3
namespace boost {
namespace detail {

struct ptr_none { };

template<class>
struct ptr_valid {
    typedef void type;
};

template<class>
struct ptr_first {
    typedef ptr_none type;
};


template<template<class, class...> class T, class U, class... Args>
struct ptr_first<T<U, Args...> > {
    typedef U type;
};
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 3
template<class T, class = void>
struct ptr_element {
    typedef typename ptr_first<T>::type type;
};

template<class T>
struct ptr_element<T, typename ptr_valid<typename T::element_type>::type> {
    typedef typename T::element_type type;
};

template<class, class = void>
struct ptr_difference {
    typedef std::ptrdiff_t type;
};

template<class T>
struct ptr_difference<T,
    typename ptr_valid<typename T::difference_type>::type> {
    typedef typename T::difference_type type;
};

template<class, class>
struct ptr_transform { };


template<template<class, class...> class T, class U, class... Args, class V>
struct ptr_transform<T<U, Args...>, V> {
    typedef T<V, Args...> type;
};
# 99 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 3
template<class T, class U, class = void>
struct ptr_rebind
    : ptr_transform<T, U> { };


template<class T, class U>
struct ptr_rebind<T, U,
    typename ptr_valid<typename T::template rebind<U> >::type> {
    typedef typename T::template rebind<U> type;
};
# 118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 3
template<class T, class E>
class ptr_to_expr {
    template<class>
    struct result {
        char x, y;
    };

    static E& source();

    template<class O>
    static auto check(int) -> result<decltype(O::pointer_to(source()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<T>(0)) > 1;
};

template<class T, class E>
struct ptr_to_expr<T*, E> {
    static constexpr bool value = true;
};

template<class T, class E>
struct ptr_has_to {
    static constexpr bool value = ptr_to_expr<T, E>::value;
};







template<class T>
struct ptr_has_to<T, void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, const void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, volatile void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, const volatile void> {
    static constexpr bool value = false;
};

template<class T, class E, bool = ptr_has_to<T, E>::value>
struct ptr_to { };

template<class T, class E>
struct ptr_to<T, E, true> {
    static T pointer_to(E& v) {
        return T::pointer_to(v);
    }
};

template<class T>
struct ptr_to<T*, T, true> {
    static T* pointer_to(T& v) noexcept {
        return boost::addressof(v);
    }
};

template<class T, class E>
struct ptr_traits
    : ptr_to<T, E> {
    typedef T pointer;
    typedef E element_type;
    typedef typename ptr_difference<T>::type difference_type;

    template<class U>
    struct rebind_to
        : ptr_rebind<T, U> { };


    template<class U>
    using rebind = typename rebind_to<U>::type;

};

template<class T>
struct ptr_traits<T, ptr_none> { };

}

template<class T>
struct pointer_traits
    : detail::ptr_traits<T, typename detail::ptr_element<T>::type> { };

template<class T>
struct pointer_traits<T*>
    : detail::ptr_to<T*, T> {
    typedef T* pointer;
    typedef T element_type;
    typedef std::ptrdiff_t difference_type;

    template<class U>
    struct rebind_to {
        typedef U* type;
    };


    template<class U>
    using rebind = typename rebind_to<U>::type;

};

template<class T>
constexpr inline T*
to_address(T* v) noexcept
{
    return v;
}


namespace detail {

template<class T>
inline T*
ptr_address(T* v, int) noexcept
{
    return v;
}

template<class T>
inline auto
ptr_address(const T& v, int) noexcept
-> decltype(boost::pointer_traits<T>::to_address(v))
{
    return boost::pointer_traits<T>::to_address(v);
}

template<class T>
inline auto
ptr_address(const T& v, long) noexcept
{
    return boost::detail::ptr_address(v.operator->(), 0);
}

}

template<class T>
inline auto
to_address(const T& v) noexcept
{
    return boost::detail::ptr_address(v, 0);
}
# 283 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/pointer_traits.hpp" 3
}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 2 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
namespace boost {

template<class A>
struct allocator_value_type {
    typedef typename A::value_type type;
};

namespace detail {

template<class A, class = void>
struct alloc_ptr {
    typedef typename boost::allocator_value_type<A>::type* type;
};

template<class>
struct alloc_void {
    typedef void type;
};

template<class A>
struct alloc_ptr<A,
    typename alloc_void<typename A::pointer>::type> {
    typedef typename A::pointer type;
};

}

template<class A>
struct allocator_pointer {
    typedef typename detail::alloc_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_const_ptr {
    typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template rebind_to<const typename
            boost::allocator_value_type<A>::type>::type type;
};

template<class A>
struct alloc_const_ptr<A,
    typename alloc_void<typename A::const_pointer>::type> {
    typedef typename A::const_pointer type;
};

}

template<class A>
struct allocator_const_pointer {
    typedef typename detail::alloc_const_ptr<A>::type type;
};

namespace detail {

template<class, class>
struct alloc_to { };
# 135 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<template<class, class...> class A, class T, class U, class... V>
struct alloc_to<A<U, V...>, T> {
    typedef A<T, V...> type;
};


template<class A, class T, class = void>
struct alloc_rebind {
    typedef typename alloc_to<A, T>::type type;
};

template<class A, class T>
struct alloc_rebind<A, T,
    typename alloc_void<typename A::template rebind<T>::other>::type> {
    typedef typename A::template rebind<T>::other type;
};

}

template<class A, class T>
struct allocator_rebind {
    typedef typename detail::alloc_rebind<A, T>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_void_ptr {
     typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template
            rebind_to<void>::type type;
};

template<class A>
struct alloc_void_ptr<A,
    typename alloc_void<typename A::void_pointer>::type> {
    typedef typename A::void_pointer type;
};

}

template<class A>
struct allocator_void_pointer {
    typedef typename detail::alloc_void_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_const_void_ptr {
     typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template
            rebind_to<const void>::type type;
};

template<class A>
struct alloc_const_void_ptr<A,
    typename alloc_void<typename A::const_void_pointer>::type> {
    typedef typename A::const_void_pointer type;
};

}

template<class A>
struct allocator_const_void_pointer {
    typedef typename detail::alloc_const_void_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_diff_type {
    typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::difference_type type;
};

template<class A>
struct alloc_diff_type<A,
    typename alloc_void<typename A::difference_type>::type> {
    typedef typename A::difference_type type;
};

}

template<class A>
struct allocator_difference_type {
    typedef typename detail::alloc_diff_type<A>::type type;
};

namespace detail {







template<class A, class = void>
struct alloc_size_type {
    typedef typename std::make_unsigned<typename
        boost::allocator_difference_type<A>::type>::type type;
};


template<class A>
struct alloc_size_type<A,
    typename alloc_void<typename A::size_type>::type> {
    typedef typename A::size_type type;
};

}

template<class A>
struct allocator_size_type {
    typedef typename detail::alloc_size_type<A>::type type;
};

namespace detail {
# 276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
typedef std::false_type alloc_false;


template<class A, class = void>
struct alloc_pocca {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocca<A,
    typename alloc_void<typename
        A::propagate_on_container_copy_assignment>::type> {
    typedef typename A::propagate_on_container_copy_assignment type;
};

}

template<class A, class = void>
struct allocator_propagate_on_container_copy_assignment {
    typedef typename detail::alloc_pocca<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_pocma {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocma<A,
    typename alloc_void<typename
        A::propagate_on_container_move_assignment>::type> {
    typedef typename A::propagate_on_container_move_assignment type;
};

}

template<class A>
struct allocator_propagate_on_container_move_assignment {
    typedef typename detail::alloc_pocma<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_pocs {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocs<A,
    typename alloc_void<typename A::propagate_on_container_swap>::type> {
    typedef typename A::propagate_on_container_swap type;
};

}

template<class A>
struct allocator_propagate_on_container_swap {
    typedef typename detail::alloc_pocs<A>::type type;
};

namespace detail {


template<class A, class = void>
struct alloc_equal {
    typedef typename std::is_empty<A>::type type;
};
# 358 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A>
struct alloc_equal<A,
    typename alloc_void<typename A::is_always_equal>::type> {
    typedef typename A::is_always_equal type;
};

}

template<class A>
struct allocator_is_always_equal {
    typedef typename detail::alloc_equal<A>::type type;
};

template<class A>
inline typename allocator_pointer<A>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n)
{
    return a.allocate(n);
}

template<class A>
inline void
allocator_deallocate(A& a, typename allocator_pointer<A>::type p,
    typename allocator_size_type<A>::type n)
{
    a.deallocate(p, n);
}
# 395 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
namespace detail {

template<class>
struct alloc_no {
    char x, y;
};

template<class A>
class alloc_has_allocate {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().allocate(std::declval<typename
        boost::allocator_size_type<A>::type>(), std::declval<typename
            boost::allocator_const_void_pointer<A>::type>()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};

}

template<class A>
inline typename std::enable_if<detail::alloc_has_allocate<A>::value,
    typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
    typename allocator_const_void_pointer<A>::type h)
{
    return a.allocate(n, h);
}

template<class A>
inline typename std::enable_if<!detail::alloc_has_allocate<A>::value,
    typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
    typename allocator_const_void_pointer<A>::type)
{
    return a.allocate(n);
}


namespace detail {
# 452 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A, class T, class... Args>
class alloc_has_construct {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().construct(std::declval<T*>(),
        std::declval<Args&&>()...))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


template<bool, class = void>
struct alloc_if { };

template<class T>
struct alloc_if<true, T> {
    typedef T type;
};

}
# 524 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A, class T, class... Args>
inline typename std::enable_if<detail::alloc_has_construct<A, T,
    Args...>::value>::type
allocator_construct(A& a, T* p, Args&&... args)
{
    a.construct(p, std::forward<Args>(args)...);
}

template<class A, class T, class... Args>
inline typename std::enable_if<!detail::alloc_has_construct<A, T,
    Args...>::value>::type
allocator_construct(A&, T* p, Args&&... args)
{
    ::new((void*)p) T(std::forward<Args>(args)...);
}


namespace detail {
# 555 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A, class T>
class alloc_has_destroy {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().destroy(std::declval<T*>()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A, class T>
inline typename detail::alloc_if<detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A& a, T* p)
{
    a.destroy(p);
}

template<class A, class T>
inline typename detail::alloc_if<!detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A&, T* p)
{
    p->~T();
    (void)p;
}

namespace detail {
# 615 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A>
class alloc_has_max_size {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<const O&>().max_size())>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A>
inline typename detail::alloc_if<detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
allocator_max_size(const A& a) noexcept
{
    return a.max_size();
}

template<class A>
inline typename detail::alloc_if<!detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
allocator_max_size(const A&) noexcept
{
    return (std::numeric_limits<typename
        allocator_size_type<A>::type>::max)() /
            sizeof(typename allocator_value_type<A>::type);
}

namespace detail {
# 673 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/allocator_access.hpp" 3
template<class A>
class alloc_has_soccc {
    template<class O>
    static auto check(int) -> alloc_no<decltype(std::declval<const
        O&>().select_on_container_copy_construction())>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A>
inline typename detail::alloc_if<detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
    return a.select_on_container_copy_construction();
}

template<class A>
inline typename detail::alloc_if<!detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
    return a;
}

template<class A, class T>
inline void
allocator_destroy_n(A& a, T* p, std::size_t n)
{
    while (n > 0) {
        boost::allocator_destroy(a, p + --n);
    }
}

namespace detail {

template<class A, class T>
class alloc_destroyer {
public:
    alloc_destroyer(A& a, T* p) noexcept
        : a_(a), p_(p), n_(0) { }

    ~alloc_destroyer() {
        boost::allocator_destroy_n(a_, p_, n_);
    }

    std::size_t& size() noexcept {
        return n_;
    }

private:
    alloc_destroyer(const alloc_destroyer&);
    alloc_destroyer& operator=(const alloc_destroyer&);

    A& a_;
    T* p_;
    std::size_t n_;
};

}

template<class A, class T>
inline void
allocator_construct_n(A& a, T* p, std::size_t n)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; ++i) {
        boost::allocator_construct(a, p + i);
    }
    d.size() = 0;
}

template<class A, class T>
inline void
allocator_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; ++i) {
        boost::allocator_construct(a, p + i, l[i % m]);
    }
    d.size() = 0;
}

template<class A, class T, class I>
inline void
allocator_construct_n(A& a, T* p, std::size_t n, I b)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; void(++i), void(++b)) {
        boost::allocator_construct(a, p + i, *b);
    }
    d.size() = 0;
}


template<class A>
using allocator_value_type_t = typename allocator_value_type<A>::type;

template<class A>
using allocator_pointer_t = typename allocator_pointer<A>::type;

template<class A>
using allocator_const_pointer_t = typename allocator_const_pointer<A>::type;

template<class A>
using allocator_void_pointer_t = typename allocator_void_pointer<A>::type;

template<class A>
using allocator_const_void_pointer_t =
    typename allocator_const_void_pointer<A>::type;

template<class A>
using allocator_difference_type_t =
    typename allocator_difference_type<A>::type;

template<class A>
using allocator_size_type_t = typename allocator_size_type<A>::type;

template<class A>
using allocator_propagate_on_container_copy_assignment_t =
    typename allocator_propagate_on_container_copy_assignment<A>::type;

template<class A>
using allocator_propagate_on_container_move_assignment_t =
    typename allocator_propagate_on_container_move_assignment<A>::type;

template<class A>
using allocator_propagate_on_container_swap_t =
    typename allocator_propagate_on_container_swap<A>::type;

template<class A>
using allocator_is_always_equal_t =
    typename allocator_is_always_equal<A>::type;

template<class A, class T>
using allocator_rebind_t = typename allocator_rebind<A, T>::type;


}



#pragma clang diagnostic pop
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/config/config.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 2 3
# 304 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/config/limits.hpp" 1 3
# 305 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/limits/inc_256.hpp" 1 3
# 308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/inc.hpp" 2 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/cat.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma_if.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/if.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/if.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/iif.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/if.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/bool.hpp" 1 3
# 296 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/bool.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/limits/bool_256.hpp" 1 3
# 297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/bool.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/if.hpp" 2 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/empty.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/debug/error.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 1 3
# 318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/limits/auto_rec_256.hpp" 1 3
# 319 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/eat.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 2 3
# 833 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/limits/repeat_256.hpp" 1 3
# 834 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat.hpp" 2 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/expand.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/overload.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/overload.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/size.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/size.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/check_empty.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/check_empty.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/has_opt.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/has_opt.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/detail/has_opt.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/has_opt.hpp" 2 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/check_empty.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/detail/is_begin_parens.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 2 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/detail/is_empty.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 2 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/check_empty.hpp" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/size.hpp" 2 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/size.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/limits/size_64.hpp" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/size.hpp" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/overload.hpp" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/rem.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/rem.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/rem.hpp" 2 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/elem.hpp" 1 3
# 102 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/elem.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/limits/elem_64.hpp" 1 3
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/variadic/elem.hpp" 2 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/tuple/elem.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/enum_params.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 1 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/dec.hpp" 1 3
# 308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/dec.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/limits/dec_256.hpp" 1 3
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/dec.hpp" 2 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 1 3
# 322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 1 3
# 323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 1 3
# 312 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 1 3
# 313 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 1 3
# 315 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 2 3
# 345 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3
# 286 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_left.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/expr_iif.hpp" 1 3
# 287 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/adt.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/adt.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/is_binary.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/is_binary.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/check.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/is_binary.hpp" 2 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/adt.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/compl.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/adt.hpp" 2 3
# 289 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/limits/fold_left_256.hpp" 1 3
# 294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3
# 346 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/limits/fold_left_256.hpp" 1 3
# 352 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_left.hpp" 2 3
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 1 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 2 3
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3
# 285 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_right.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/reverse.hpp" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/reverse.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/facilities/identity.hpp" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/reverse.hpp" 2 3
# 286 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/limits/fold_right_256.hpp" 1 3
# 290 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/list/fold_right.hpp" 2 3
# 325 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/bitand.hpp" 1 3
# 326 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 361 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/detail/while.hpp" 1 3
# 549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/detail/while.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/detail/limits/while_256.hpp" 1 3
# 550 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/detail/while.hpp" 2 3
# 362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 375 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/limits/while_256.hpp" 1 3
# 376 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/control/while.hpp" 2 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/bitor.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/equal.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/equal.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/not_equal.hpp" 1 3
# 843 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/not_equal.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/limits/not_equal_256.hpp" 1 3
# 844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/not_equal.hpp" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/comparison/equal.hpp" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/maximum_number.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 2 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/not.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 2 3
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/add.hpp" 2 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/sub.hpp" 1 3
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/sub.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/logical/and.hpp" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/arithmetic/sub.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/detail/auto_rec.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/enable_if.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 2 3
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
namespace boost
{

namespace detail
{
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
template < typename T >
struct remove_cv_ref
{
    typedef typename ::boost::remove_cv<typename
     ::boost::remove_reference<T>::type>::type type;

};







template < typename T, typename U >
struct is_related
    : public ::boost::is_same<
     typename ::boost::detail::remove_cv_ref<T>::type,
     typename ::boost::detail::remove_cv_ref<U>::type >
{};
# 101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
template<typename ...T>
struct enable_if_unrelated
    : public ::boost::enable_if_c<true>
{};

template<typename T, typename U, typename ...U2>
struct enable_if_unrelated<T, U, U2...>
    : public ::boost::disable_if< ::boost::detail::is_related<T, U> >
{};


}
# 124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
template < typename MemberType, int UniqueID = 0 >
class base_from_member
{
protected:
    MemberType member;
# 142 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/utility/base_from_member.hpp" 3
    base_from_member()
        : member()
        {}

    template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
    template < typename T0 , typename T1 > base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}



};

template < typename MemberType, int UniqueID >
class base_from_member<MemberType&, UniqueID>
{
protected:
    MemberType& member;

    explicit constexpr base_from_member( MemberType& x )
        noexcept
        : member( x )
        {}

};

}
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/shared_ptr.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/shared_ptr.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/bad_weak_ptr.hpp" 3
namespace boost
{



#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"


class bad_weak_ptr: public std::exception
{
public:

    char const * what() const noexcept override
    {
        return "tr1::bad_weak_ptr";
    }
};


#pragma clang diagnostic pop


}
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/deprecated_macros.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 3
namespace boost
{

namespace detail
{

typedef std::type_info sp_typeinfo_;

}

}
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 3
namespace boost
{

namespace detail
{

inline void atomic_increment( std::atomic_int_least32_t * pw ) noexcept
{
    pw->fetch_add( 1, std::memory_order_relaxed );
}

inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) noexcept
{
    return pw->fetch_sub( 1, std::memory_order_acq_rel );
}

inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw ) noexcept
{




    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 __attribute__((__visibility__("default"))) 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() noexcept: use_count_( 1 ), weak_count_( 1 )
    {
    }

    virtual ~sp_counted_base()
    {
    }




    virtual void dispose() noexcept = 0;



    virtual void destroy() noexcept
    {
        delete this;
    }

    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
    virtual void * get_untyped_deleter() noexcept = 0;

    void add_ref_copy() noexcept
    {
        atomic_increment( &use_count_ );
    }

    bool add_ref_lock() noexcept
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }

    void release() noexcept
    {
        if( atomic_decrement( &use_count_ ) == 1 )
        {
            dispose();
            weak_release();
        }
    }

    void weak_add_ref() noexcept
    {
        atomic_increment( &weak_count_ );
    }

    void weak_release() noexcept
    {
        if( atomic_decrement( &weak_count_ ) == 1 )
        {
            destroy();
        }
    }

    long use_count() const noexcept
    {
        return use_count_.load( std::memory_order_acquire );
    }
};

}

}
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/checked_delete.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/checked_delete.hpp" 3
namespace boost
{



template<class T> inline void checked_delete(T * x) noexcept
{


    static_assert( sizeof(T) != 0, "Type must be complete" );
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/checked_delete.hpp" 3
    delete x;
}

template<class T> inline void checked_array_delete(T * x) noexcept
{


    static_assert( sizeof(T) != 0, "Type must be complete" );
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/checked_delete.hpp" 3
    delete [] x;
}


namespace checked_deleters
{

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const noexcept
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const noexcept
    {
        boost::checked_array_delete(x);
    }
};

}

using checked_deleters::checked_deleter;
using checked_deleters::checked_array_deleter;

}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 1 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 1 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
  namespace __detail
  {


    template<typename _Tp>
      inline _Tp*
      __get_temporary_buffer(ptrdiff_t __len) noexcept
      {
 if (__builtin_expect(size_t(__len) > (size_t(-1) / sizeof(_Tp)), 0))
   return 0;


 if (alignof(_Tp) > 16UL)
   return (_Tp*) __builtin_operator_new(__len * sizeof(_Tp),
           align_val_t(alignof(_Tp)),
           nothrow_t());

 return (_Tp*) __builtin_operator_new(__len * sizeof(_Tp), nothrow_t());
      }



    template<typename _Tp>
      inline void
      __return_temporary_buffer(_Tp* __p,
    size_t __len __attribute__((__unused__)))
      {







 if (alignof(_Tp) > 16UL)
   {
     __builtin_operator_delete((__p), (__len) * sizeof(_Tp),
         align_val_t(alignof(_Tp)));
     return;
   }

 __builtin_operator_delete((__p), (__len) * sizeof(_Tp));
      }

  }
# 140 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    [[__deprecated__]]
    pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len) noexcept
    {
      const ptrdiff_t __max =
 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   if (_Tp* __tmp = __detail::__get_temporary_buffer<_Tp>(__len))
     return pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len = __len == 1 ? 0 : ((__len + 1) / 2);
 }
      return pair<_Tp*, ptrdiff_t>();
    }
# 166 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    [[__deprecated__]]
    inline void
    return_temporary_buffer(_Tp* __p)
    {

      if (alignof(_Tp) > 16UL)
 __builtin_operator_delete(__p, align_val_t(alignof(_Tp)));
      else

      __builtin_operator_delete(__p);
    }
# 187 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
  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;
      struct _Impl
      {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 explicit
 _Impl(ptrdiff_t __original_len)
 {
   pair<pointer, size_type> __p(
     std::get_temporary_buffer<value_type>(__original_len));
   _M_len = __p.second;
   _M_buffer = __p.first;
 }
#pragma GCC diagnostic pop

 ~_Impl()
 { std::__detail::__return_temporary_buffer(_M_buffer, _M_len); }

 size_type _M_len;
 pointer _M_buffer;
      } _M_impl;

    public:

      size_type
      size() const
      { return _M_impl._M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_impl._M_buffer; }


      iterator
      end()
      { return _M_impl._M_buffer + _M_impl._M_len; }





      _Temporary_buffer(_ForwardIterator __seed, size_type __original_len);

      ~_Temporary_buffer()
      { std::_Destroy(_M_impl._M_buffer, _M_impl._M_buffer + _M_impl._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 (__builtin_expect(__first == __last, 0))
     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) { }
    };
# 311 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_tempbuf.h" 3
  template<typename _Tp, typename _ForwardIterator>
    inline void
    __uninitialized_construct_buf(_Tp* __first, _Tp* __last,
      _ForwardIterator __seed)
    {
      std::__uninitialized_construct_buf_dispatch<
 __has_trivial_constructor(_Tp)>::
   __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_impl(__original_len)
    {
      std::__uninitialized_construct_buf(begin(), end(), __seed);
    }


}
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_raw_storage_iter.h" 1 3
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_raw_storage_iter.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"





  template <class _OutputIterator, class _Tp>
    class [[__deprecated__]] raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _OutputIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_OutputIterator __x)
      : _M_iter(__x) {}

      raw_storage_iterator&
      operator*() { return *this; }

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), __element);
 return *this;
      }




      raw_storage_iterator&
      operator=(_Tp&& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), std::move(__element));
 return *this;
      }


      raw_storage_iterator&
      operator++()
      {
 ++_M_iter;
 return *this;
      }

      raw_storage_iterator
      operator++(int)
      {
 raw_storage_iterator __tmp = *this;
 ++_M_iter;
 return __tmp;
      }



      _OutputIterator base() const { return _M_iter; }
    };
#pragma GCC diagnostic pop


}
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/align.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/align.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/align.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/align.h" 3
inline void*
align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
{
  if (__space < __size)
    return nullptr;
  const auto __intptr = reinterpret_cast<long unsigned int>(__ptr);
  const auto __aligned = (__intptr - 1u + __align) & -__align;
  const auto __diff = __aligned - __intptr;
  if (__diff > (__space - __size))
    return nullptr;
  else
    {
      __space -= __diff;
      return __ptr = reinterpret_cast<void*>(__aligned);
    }
}
# 87 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/align.h" 3
  template<size_t _Align, class _Tp>
    [[nodiscard,__gnu__::__always_inline__]]
    constexpr _Tp*
    assume_aligned(_Tp* __ptr) noexcept
    {
      static_assert(std::has_single_bit(_Align));
      if (std::is_constant_evaluated())
 return __ptr;
      else
 {


                                                               ;
   return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align));
 }
    }



}
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
    };
# 105 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp>
    struct default_delete<_Tp[]>
    {
    public:

      constexpr default_delete() noexcept = default;
# 121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() noexcept { return std::get<0>(_M_t); }

      pointer _M_ptr() const noexcept { return std::get<0>(_M_t); }

      _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); }

      const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); }


      void reset(pointer __p) noexcept
      {
 const pointer __old_p = _M_ptr();
 _M_ptr() = __p;
 if (__old_p)
   _M_deleter()(__old_p);
      }


      pointer release() noexcept
      {
 pointer __p = _M_ptr();
 _M_ptr() = nullptr;
 return __p;
      }


      void
      swap(__uniq_ptr_impl& __rhs) noexcept
      {
 using std::swap;
 swap(this->_M_ptr(), __rhs._M_ptr());
 swap(this->_M_deleter(), __rhs._M_deleter());
      }

    private:
      tuple<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)
        { }
# 322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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) { }
# 335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>,
        __conditional_t<is_reference<_Dp>::value,
          is_same<_Ep, _Dp>,
          is_convertible<_Ep, _Dp>>>>

 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*, pointer>,
       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;
# 418 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 noexcept(noexcept(*std::declval<pointer>()))
      {



 using _ResT = typename add_lvalue_reference<element_type>::type;
 using _DerefT = decltype(*get());
 static_assert(!__reference_converts_from_temporary(_ResT, _DerefT),
        "operator* must not return a dangling reference");

 do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) std::__glibcxx_assert_fail(); } 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(); }
# 507 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
      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
      {
 static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
 _M_t.swap(__u._M_t);
      }


      unique_ptr(const unique_ptr&) = delete;
      unique_ptr& operator=(const unique_ptr&) = delete;

    private:






  };
# 545 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp, typename _Dp>
    class unique_ptr<_Tp[], _Dp>
    {
      template <typename _Up>
      using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

      __uniq_ptr_data<_Tp, _Dp> _M_t;


      template<typename _Up>
 using __is_derived_Tp
   = __and_< is_base_of<_Tp, _Up>,
      __not_<is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up>>> >;

    public:
      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
      using element_type = _Tp;
      using deleter_type = _Dp;



      template<typename _Up, typename _Ep,
               typename _UPtr = unique_ptr<_Up, _Ep>,
        typename _UP_pointer = typename _UPtr::pointer,
        typename _UP_element_type = typename _UPtr::element_type>
 using __safe_conversion_up = __and_<
          is_array<_Up>,
          is_same<pointer, element_type*>,
          is_same<_UP_pointer, _UP_element_type*>,
          is_convertible<_UP_element_type(*)[], element_type(*)[]>
        >;


      template<typename _Up>
        using __safe_conversion_raw = __and_<
          __or_<__or_<is_same<_Up, pointer>,
                      is_same<_Up, nullptr_t>>,
                __and_<is_pointer<_Up>,
                       is_same<pointer, element_type*>,
                       is_convertible<
                         typename remove_pointer<_Up>::type(*)[],
                         element_type(*)[]>
                >
          >
        >;




      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr() noexcept
 : _M_t()
 { }
# 607 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
        { }
# 626 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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) { }
# 641 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>,
        __conditional_t<is_reference<_Dp>::value,
          is_same<_Ep, _Dp>,
          is_convertible<_Ep, _Dp>>>>

 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;
# 705 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 (std::__is_constant_evaluated() && !bool(get() != pointer())) std::__glibcxx_assert_fail(); } 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
      {
 static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
 _M_t.swap(__u._M_t);
      }


      unique_ptr(const unique_ptr&) = delete;
      unique_ptr& operator=(const unique_ptr&) = delete;

    private:




    };





  template<typename _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; }
# 890 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  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 _Tp, typename _Dp, typename _Up, typename _Ep>
    requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
           typename unique_ptr<_Up, _Ep>::pointer>

    inline
    compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
          typename unique_ptr<_Up, _Ep>::pointer>
    operator<=>(const unique_ptr<_Tp, _Dp>& __x,
  const unique_ptr<_Up, _Ep>& __y)
    { return compare_three_way()(__x.get(), __y.get()); }

  template<typename _Tp, typename _Dp>
    requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>

    inline
    compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
    operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    {
      using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
      return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
    }




  template<typename _Up, typename _Ptr = typename _Up::pointer>
    struct __uniq_ptr_hash
    : public __hash_base<size_t, _Up>

    , private __hash_empty_base<_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>
    using __uniq_ptr_hash_base
      = __conditional_t<__is_hash_enabled_for<typename _Up::pointer>,
        __uniq_ptr_hash<_Up>,
        __hash_not_enabled<typename _Up::pointer>>;



  template<typename _Tp, typename _Dp>
    struct hash<unique_ptr<_Tp, _Dp>>
    : public __uniq_ptr_hash_base<unique_ptr<_Tp, _Dp>>
    { };



namespace __detail
{
  template<typename _Tp>
    struct _MakeUniq
    { typedef unique_ptr<_Tp> __single_object; };

  template<typename _Tp>
    struct _MakeUniq<_Tp[]>
    { typedef unique_ptr<_Tp[]> __array; };

  template<typename _Tp, size_t _Bound>
    struct _MakeUniq<_Tp[_Bound]>
    { struct __invalid_type { }; };

  template<typename _Tp>
    using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object;
  template<typename _Tp>
    using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array;
  template<typename _Tp>
    using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type;
}
# 1081 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp, typename... _Args>

    inline __detail::__unique_ptr_t<_Tp>
    make_unique(_Args&&... __args)
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
# 1096 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp>

    inline __detail::__unique_ptr_array_t<_Tp>
    make_unique(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }






  template<typename _Tp, typename... _Args>
    __detail::__invalid_make_unique_t<_Tp>
    make_unique(_Args&&...) = delete;
# 1118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp>

    inline __detail::__unique_ptr_t<_Tp>
    make_unique_for_overwrite()
    { return unique_ptr<_Tp>(new _Tp); }
# 1131 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _Tp>

    inline __detail::__unique_ptr_array_t<_Tp>
    make_unique_for_overwrite(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]); }






  template<typename _Tp, typename... _Args>
    __detail::__invalid_make_unique_t<_Tp>
    make_unique_for_overwrite(_Args&&...) = delete;
# 1155 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_ptr.h" 3
  template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const unique_ptr<_Tp, _Dp>& __p)
    requires requires { __os << __p.get(); }
    {
      __os << __p.get();
      return __os;
    }



  template<typename _Tp>
    constexpr bool __is_unique_ptr = false;
  template<typename _Tp, typename _Del>
    constexpr bool __is_unique_ptr<unique_ptr<_Tp, _Del>> = true;





  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Del>
      struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
      : std::true_type
      { };
  }



}
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/allocated_ptr.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }

      explicit operator bool() const noexcept { return (bool)_M_ptr; }


      value_type* get() const { return std::__to_address(_M_ptr); }

      pointer release() { return std::__exchange(_M_ptr, nullptr); }

    private:
      _Alloc* _M_alloc;
      pointer _M_ptr;
    };


  template<typename _Alloc>
    inline __allocated_ptr<_Alloc>
    __allocate_guarded(_Alloc& __a)
    {
      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
    }


  template<typename _Alloc>
    struct __allocated_obj : __allocated_ptr<_Alloc>
    {
      using value_type = typename __allocated_ptr<_Alloc>::value_type;

      __allocated_obj(__allocated_obj<_Alloc>&&) = default;


      __allocated_obj(__allocated_ptr<_Alloc>&& __ptr)
      : __allocated_ptr<_Alloc>(std::move(__ptr))
      { ::new ((void*)this->get()) value_type; }


      ~__allocated_obj()
      {
 if (static_cast<bool>(*this))
   this->get()->~value_type();
      }

      using __allocated_ptr<_Alloc>::operator=;

      value_type& operator*() const { return *this->get(); }
      value_type* operator->() const { return this->get(); }
    };


  template<typename _Alloc>
    inline __allocated_obj<_Alloc>
    __allocate_guarded_obj(_Alloc& __a)
    {
      return { std::__allocate_guarded(__a) };
    }



}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 2 3








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/concurrence.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ext/concurrence.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{







  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };



  inline const _Lock_policy __default_lock_policy =



  _S_atomic;






  class __concurrence_lock_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_lock_error"; }
  };

  class __concurrence_unlock_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_unlock_error"; }
  };

  class __concurrence_broadcast_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_broadcast_error"; }
  };

  class __concurrence_wait_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_wait_error"; }
  };


  inline void
  __throw_concurrence_lock_error()
  { (throw (__concurrence_lock_error())); }

  inline void
  __throw_concurrence_unlock_error()
  { (throw (__concurrence_unlock_error())); }


  inline void
  __throw_concurrence_broadcast_error()
  { (throw (__concurrence_broadcast_error())); }

  inline void
  __throw_concurrence_wait_error()
  { (throw (__concurrence_wait_error())); }


  class __mutex
  {
  private:

    __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } };




    __mutex(const __mutex&);
    __mutex& operator=(const __mutex&);

  public:
    __mutex()
    {




    }
# 149 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()
    {




    }
# 204 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()
    {




    }
# 282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
      }

    }
  };



}

#pragma GCC diagnostic pop
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename> class auto_ptr;
#pragma GCC diagnostic pop






  class bad_weak_ptr : public std::exception
  {
  public:
    virtual char const* what() const noexcept;

    virtual ~bad_weak_ptr() noexcept;
  };


  inline void
  __throw_bad_weak_ptr()
  { (throw (bad_weak_ptr())); }

  using __gnu_cxx::_Lock_policy;
  using __gnu_cxx::__default_lock_policy;
  using __gnu_cxx::_S_single;
  using __gnu_cxx::_S_mutex;
  using __gnu_cxx::_S_atomic;


  template<_Lock_policy _Lp>
    class _Mutex_base
    {
    protected:

      enum { _S_need_barriers = 0 };
    };

  template<>
    class _Mutex_base<_S_mutex>
    : public __gnu_cxx::__mutex
    {
    protected:



      enum { _S_need_barriers = 1 };
    };

  template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base
    : public _Mutex_base<_Lp>
    {
    public:
      _Sp_counted_base() noexcept
      : _M_use_count(1), _M_weak_count(1) { }

      virtual
      ~_Sp_counted_base() noexcept
      { }



      virtual void
      _M_dispose() noexcept = 0;


      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept = 0;


      void
      _M_add_ref_copy()
      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }


      void
      _M_add_ref_lock()
      {
 if (!_M_add_ref_lock_nothrow())
   __throw_bad_weak_ptr();
      }


      bool
      _M_add_ref_lock_nothrow() noexcept;


      void
      _M_release() noexcept;


      void
      _M_release_last_use() noexcept
      {
                                                      ;
 _M_dispose();




 if (_Mutex_base<_Lp>::_S_need_barriers)
   {
     __atomic_thread_fence (4);
   }


                                                        ;
 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
         -1) == 1)
   {
                                                           ;
     _M_destroy();
   }
      }


      __attribute__((__noinline__))
      void
      _M_release_last_use_cold() noexcept
      { _M_release_last_use(); }


      void
      _M_weak_add_ref() noexcept
      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }


      void
      _M_weak_release() noexcept
      {

                                                               ;
 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
   {
                                                                  ;
     if (_Mutex_base<_Lp>::_S_need_barriers)
       {


  __atomic_thread_fence (4);
       }
     _M_destroy();
   }
      }

      long
      _M_get_use_count() const noexcept
      {


        return __atomic_load_n(&_M_use_count, 0);
      }

    private:
      _Sp_counted_base(_Sp_counted_base const&) = delete;
      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

      _Atomic_word _M_use_count;
      _Atomic_word _M_weak_count;
    };

  template<>
    inline bool
    _Sp_counted_base<_S_single>::
    _M_add_ref_lock_nothrow() noexcept
    {
      if (_M_use_count == 0)
 return false;
      ++_M_use_count;
      return true;
    }

  template<>
    inline bool
    _Sp_counted_base<_S_mutex>::
    _M_add_ref_lock_nothrow() noexcept
    {
      __gnu_cxx::__scoped_lock sentry(*this);
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
 {
   _M_use_count = 0;
   return false;
 }
      return true;
    }

  template<>
    inline bool
    _Sp_counted_base<_S_atomic>::
    _M_add_ref_lock_nothrow() noexcept
    {

      _Atomic_word __count = _M_get_use_count();
      do
 {
   if (__count == 0)
     return false;


 }
      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
       true, 4,
       0));
      return true;
    }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_add_ref_copy()
    { ++_M_use_count; }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_release() noexcept
    {
      if (--_M_use_count == 0)
        {
          _M_dispose();
          if (--_M_weak_count == 0)
            _M_destroy();
        }
    }

  template<>
    inline void
    _Sp_counted_base<_S_mutex>::_M_release() noexcept
    {

                                                            ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
   _M_release_last_use();
 }
    }

  template<>
    inline void
    _Sp_counted_base<_S_atomic>::_M_release() noexcept
    {
                                                            ;

      constexpr bool __lock_free
 = __atomic_always_lock_free(sizeof(long long), 0)
 && __atomic_always_lock_free(sizeof(_Atomic_word), 0);
      constexpr bool __double_word
 = sizeof(long long) == 2 * sizeof(_Atomic_word);


      constexpr bool __aligned = __alignof(long long) <= alignof(void*);
      if constexpr (__lock_free && __double_word && __aligned)
 {
   constexpr int __wordbits = 8 * sizeof(_Atomic_word);
   constexpr int __shiftbits = __double_word ? __wordbits : 0;
   constexpr long long __unique_ref = 1LL + (1LL << __shiftbits);
   auto __both_counts = reinterpret_cast<long long*>(&_M_use_count);

                                                          ;
   if (__atomic_load_n(__both_counts, 2) == __unique_ref)
     {




       _M_weak_count = _M_use_count = 0;
                                                            ;
                                                             ;
       _M_dispose();
       _M_destroy();
       return;
     }
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
     [[__unlikely__]]
     {
       _M_release_last_use_cold();
       return;
     }
 }
      else

      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
   _M_release_last_use();
 }
    }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
    { ++_M_weak_count; }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
    {
      if (--_M_weak_count == 0)
        _M_destroy();
    }

  template<>
    inline long
    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
    { return _M_use_count; }



  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __shared_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __weak_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __enable_shared_from_this;

  template<typename _Tp>
    class shared_ptr;

  template<typename _Tp>
    class weak_ptr;

  template<typename _Tp>
    struct owner_less;

  template<typename _Tp>
    class enable_shared_from_this;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __weak_count;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __shared_count;


  template<typename>
    class _Sp_atomic;



  template<typename _Ptr, _Lock_policy _Lp>
    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
    {
    public:
      explicit
      _Sp_counted_ptr(_Ptr __p) noexcept
      : _M_ptr(__p) { }

      virtual void
      _M_dispose() noexcept
      { delete _M_ptr; }

      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept
      { return nullptr; }

      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

    private:
      _Ptr _M_ptr;
    };

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }






  template<int _Nm, typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Sp_ebo_helper;


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
    };


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, false>
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh)
      { return __eboh._M_tp; }

    private:
      _Tp _M_tp;
    };


  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
    {
      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
      {
 typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
 typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;

      public:
 _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
 : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p)
 { }

 _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
 _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

 _Ptr _M_ptr;
      };

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;


      _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
      : _M_impl(__p, std::move(__d), _Alloc()) { }


      _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
      : _M_impl(__p, std::move(__d), __a) { }

      ~_Sp_counted_deleter() noexcept { }

      virtual void
      _M_dispose() noexcept
      { _M_impl._M_del()(_M_impl._M_ptr); }

      virtual void
      _M_destroy() noexcept
      {
 __allocator_type __a(_M_impl._M_alloc());
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
 this->~_Sp_counted_deleter();
      }

      virtual void*
      _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept
      {



        return __ti == typeid(_Deleter)
   ? std::__addressof(_M_impl._M_del())
   : nullptr;



      }

    private:



      _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<__remove_cv_t<_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
      {




 if (&__ti == &_Sp_make_shared_tag::_S_ti()
     ||

     __ti == typeid(_Sp_make_shared_tag)



    )
   return _M_ptr();
 return nullptr;
      }

      __remove_cv_t<_Tp>*
      _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

      _Impl _M_impl;
    };


  struct _Sp_overwrite_tag { };





  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    requires is_same_v<typename _Alloc::value_type, _Sp_overwrite_tag>
    class _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> final




    : public _Sp_counted_base<_Lp>
    {
      [[no_unique_address]] _Alloc _M_alloc;

      union {
 remove_cv_t<_Tp> _M_obj;
 char _M_unused;
      };

      friend class __shared_count<_Lp>;

      auto _M_ptr() noexcept { return std::__addressof(_M_obj); }

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

      _Sp_counted_ptr_inplace(const _Alloc& __a)
      : _M_alloc(__a)
      {
 ::new((void*)_M_ptr()) _Tp;
      }

      ~_Sp_counted_ptr_inplace() noexcept { }

      virtual void
      _M_dispose() noexcept
      {
 _M_obj.~_Tp();
      }


      virtual void
      _M_destroy() noexcept
      {
 using pointer = typename allocator_traits<__allocator_type>::pointer;
 __allocator_type __a(_M_alloc);
 auto __p = pointer_traits<pointer>::pointer_to(*this);
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, __p };
 this->~_Sp_counted_ptr_inplace();
      }

      void*
      _M_get_deleter(const std::type_info&) noexcept override
      { return nullptr; }
    };



  struct _Sp_overwrite_tag;


  template<typename _Alloc>
    struct _Sp_counted_array_base
    {
      [[no_unique_address]] _Alloc _M_alloc{};
      size_t _M_n = 0;
      bool _M_overwrite = false;

      typename allocator_traits<_Alloc>::pointer
      _M_alloc_array(size_t __tail)
      {
 return allocator_traits<_Alloc>::allocate(_M_alloc, _M_n + __tail);
      }

      void
      _M_dealloc_array(typename allocator_traits<_Alloc>::pointer __p,
         size_t __tail)
      {
 allocator_traits<_Alloc>::deallocate(_M_alloc, __p, _M_n + __tail);
      }


      template<typename _Init>
 void
 _M_init(typename allocator_traits<_Alloc>::value_type* __p,
  _Init __init)
 {
   using _Tp = remove_pointer_t<_Init>;
   using _Up = typename allocator_traits<_Alloc>::value_type;

   if constexpr (is_same_v<_Init, _Sp_overwrite_tag>)
     {
       std::uninitialized_default_construct_n(__p, _M_n);
       _M_overwrite = true;
     }
   else if (__init == nullptr)
     std::__uninitialized_default_n_a(__p, _M_n, _M_alloc);
   else if constexpr (!is_array_v<_Tp>)
     std::__uninitialized_fill_n_a(__p, _M_n, *__init, _M_alloc);
   else
     {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
       struct _Iter
       {
  using value_type = _Up;
  using difference_type = ptrdiff_t;
  using pointer = const _Up*;
  using reference = const _Up&;
  using iterator_category = forward_iterator_tag;

  const _Up* _M_p;
  size_t _M_len;
  size_t _M_pos;

  _Iter& operator++() { ++_M_pos; return *this; }
  _Iter operator++(int) { auto __i(*this); ++_M_pos; return __i; }

  reference operator*() const { return _M_p[_M_pos % _M_len]; }
  pointer operator->() const { return _M_p + (_M_pos % _M_len); }

  bool operator==(const _Iter& __i) const
  { return _M_pos == __i._M_pos; }
       };
#pragma GCC diagnostic pop

       _Iter __first{_S_first_elem(__init), sizeof(_Tp) / sizeof(_Up)};
       _Iter __last = __first;
       __last._M_pos = _M_n;
       std::__uninitialized_copy_a(__first, __last, __p, _M_alloc);
     }
 }

    protected:

      void
      _M_dispose_array(typename allocator_traits<_Alloc>::value_type* __p)
      {
 if (_M_overwrite)
   std::destroy_n(__p, _M_n);
 else
   {
     size_t __n = _M_n;
     while (__n--)
       allocator_traits<_Alloc>::destroy(_M_alloc, __p + __n);
   }
      }

    private:
      template<typename _Tp>
 static _Tp*
 _S_first_elem(_Tp* __p) { return __p; }

      template<typename _Tp, size_t _Nm>
 static auto
 _S_first_elem(_Tp (*__p)[_Nm]) { return _S_first_elem(*__p); }
    };



  template<typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_array final
    : public _Sp_counted_base<_Lp>, _Sp_counted_array_base<_Alloc>
    {
      using pointer = typename allocator_traits<_Alloc>::pointer;

      pointer _M_alloc_ptr;

      auto _M_ptr() const noexcept { return std::to_address(_M_alloc_ptr); }

      friend class __shared_count<_Lp>;

    public:
      _Sp_counted_array(const _Sp_counted_array_base<_Alloc>& __a,
   pointer __p) noexcept
      : _Sp_counted_array_base<_Alloc>(__a), _M_alloc_ptr(__p)
      { }

      ~_Sp_counted_array() = default;

      virtual void
      _M_dispose() noexcept
      {
 if (this->_M_n)
   this->_M_dispose_array(_M_ptr());
      }


      virtual void
      _M_destroy() noexcept
      {
 _Sp_counted_array_base<_Alloc> __a = *this;
 pointer __p = _M_alloc_ptr;
 this->~_Sp_counted_array();
 __a._M_dealloc_array(__p, _S_tail());
      }



      static constexpr size_t
      _S_tail()
      {

 using _Tp = typename allocator_traits<_Alloc>::value_type;


 size_t __bytes = sizeof(_Sp_counted_array);


 if constexpr (alignof(_Tp) < alignof(_Sp_counted_array))
   __bytes += alignof(_Sp_counted_array) - alignof(_Tp);

 return (__bytes + sizeof(_Tp) - 1) / sizeof(_Tp);
      }

      void*
      _M_get_deleter(const std::type_info&) noexcept override
      { return nullptr; }
    };



  struct __sp_array_delete
  {
    template<typename _Yp>
      void operator()(_Yp* __p) const { delete[] __p; }
  };

  template<_Lock_policy _Lp>
    class __shared_count
    {

      template<typename _Tp>
 struct __not_alloc_shared_tag { using type = void; };

      template<typename _Tp>
 struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };


      template<typename _Alloc>
 struct __not_alloc_shared_tag<_Sp_counted_array_base<_Alloc>> { };


    public:
      constexpr __shared_count() noexcept : _M_pi(0)
      { }

      template<typename _Ptr>
        explicit
 __shared_count(_Ptr __p) : _M_pi(0)
 {
   try
     {
       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
     }
   catch(...)
     {
       delete __p;
       throw;
     }
 }

      template<typename _Ptr>
 __shared_count(_Ptr __p, false_type)
 : __shared_count(__p)
 { }

      template<typename _Ptr>
 __shared_count(_Ptr __p, true_type)
 : __shared_count(__p, __sp_array_delete{}, allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d)
 : __shared_count(__p, std::move(__d), allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter, typename _Alloc,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
 {
   typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
   try
     {
       typename _Sp_cd_type::__allocator_type __a2(__a);
       auto __guard = std::__allocate_guarded(__a2);
       _Sp_cd_type* __mem = __guard.get();
       ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
       _M_pi = __mem;
       __guard = nullptr;
     }
   catch(...)
     {
       __d(__p);
       throw;
     }
 }

      template<typename _Tp, typename _Alloc, typename... _Args>
 __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
         _Args&&... __args)
 {
   using _Tp2 = __remove_cv_t<_Tp>;
   using _Sp_cp_type = _Sp_counted_ptr_inplace<_Tp2, _Alloc, _Lp>;
   typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
   auto __guard = std::__allocate_guarded(__a2);
   _Sp_cp_type* __mem = __guard.get();
   auto __pi = ::new (__mem)
     _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
   __guard = nullptr;
   _M_pi = __pi;
   __p = __pi->_M_ptr();
 }


      template<typename _Tp, typename _Alloc, typename _Init>
 __shared_count(_Tp*& __p, const _Sp_counted_array_base<_Alloc>& __a,
         _Init __init)
 {
   using _Up = remove_all_extents_t<_Tp>;
   static_assert(is_same_v<_Up, typename _Alloc::value_type>);

   using _Sp_ca_type = _Sp_counted_array<_Alloc, _Lp>;
   const size_t __tail = _Sp_ca_type::_S_tail();

   struct _Guarded_ptr : _Sp_counted_array_base<_Alloc>
   {
     typename allocator_traits<_Alloc>::pointer _M_ptr;

     _Guarded_ptr(_Sp_counted_array_base<_Alloc> __a)
     : _Sp_counted_array_base<_Alloc>(__a),
       _M_ptr(this->_M_alloc_array(_Sp_ca_type::_S_tail()))
     { }

     ~_Guarded_ptr()
     {
       if (_M_ptr)
  this->_M_dealloc_array(_M_ptr, _Sp_ca_type::_S_tail());
     }
   };

   _Guarded_ptr __guard{__a};
   _Up* const __raw = std::to_address(__guard._M_ptr);
   __guard._M_init(__raw, __init);

   void* __c = __raw + __a._M_n;
   if constexpr (alignof(_Up) < alignof(_Sp_ca_type))
     {
       size_t __space = sizeof(_Up) * __tail;
       __c = std::align(alignof(_Sp_ca_type), sizeof(_Sp_ca_type),
          __c, __space);
     }
   auto __pi = ::new(__c) _Sp_ca_type(__guard, __guard._M_ptr);
   __guard._M_ptr = nullptr;
   _M_pi = __pi;
   __p = reinterpret_cast<_Tp*>(__raw);
 }



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      template<typename _Tp>
        explicit
 __shared_count(std::auto_ptr<_Tp>&& __r);
#pragma GCC diagnostic pop



      template<typename _Tp, typename _Del>
        explicit
 __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
 {


   if (__r.get() == nullptr)
     return;

   using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
   using _Del2 = __conditional_t<is_reference<_Del>::value,
       reference_wrapper<typename remove_reference<_Del>::type>,
       _Del>;
   using _Sp_cd_type
     = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
   using _Alloc = allocator<_Sp_cd_type>;
   using _Alloc_traits = allocator_traits<_Alloc>;
   _Alloc __a;
   _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);



   _Alloc_traits::construct(__a, __mem, __r.release(),
       std::forward<_Del>(__r.get_deleter()));
   _M_pi = __mem;
 }


      explicit __shared_count(const __weak_count<_Lp>& __r);


      explicit
      __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept;

      ~__shared_count() noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_release();
      }

      __shared_count(const __shared_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != nullptr)
   _M_pi->_M_add_ref_copy();
      }

      __shared_count&
      operator=(const __shared_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != _M_pi)
   {
     if (__tmp != nullptr)
       __tmp->_M_add_ref_copy();
     if (_M_pi != nullptr)
       _M_pi->_M_release();
     _M_pi = __tmp;
   }
 return *this;
      }

      void
      _M_swap(__shared_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 __r._M_pi = _M_pi;
 _M_pi = __tmp;
      }

      long
      _M_get_use_count() const noexcept
      { return _M_pi ? _M_pi->_M_get_use_count() : 0; }

      bool
      _M_unique() const noexcept
      { return this->_M_get_use_count() == 1; }

      void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

      bool
      _M_less(const __shared_count& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

      bool
      _M_less(const __weak_count<_Lp>& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }


      friend inline bool
      operator==(const __shared_count& __a, const __shared_count& __b) noexcept
      { return __a._M_pi == __b._M_pi; }

    private:
      friend class __weak_count<_Lp>;

      template<typename> friend class _Sp_atomic;





      _Sp_counted_base<_Lp>* _M_pi;
    };


  template<_Lock_policy _Lp>
    class __weak_count
    {
    public:
      constexpr __weak_count() noexcept : _M_pi(nullptr)
      { }

      __weak_count(const __shared_count<_Lp>& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_add_ref();
      }

      __weak_count(const __weak_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_add_ref();
      }

      __weak_count(__weak_count&& __r) noexcept
      : _M_pi(__r._M_pi)
      { __r._M_pi = nullptr; }

      ~__weak_count() noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
      }

      __weak_count&
      operator=(const __shared_count<_Lp>& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != nullptr)
   __tmp->_M_weak_add_ref();
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __tmp;
 return *this;
      }

      __weak_count&
      operator=(const __weak_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != nullptr)
   __tmp->_M_weak_add_ref();
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __tmp;
 return *this;
      }

      __weak_count&
      operator=(__weak_count&& __r) noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __r._M_pi;
        __r._M_pi = nullptr;
 return *this;
      }

      void
      _M_swap(__weak_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 __r._M_pi = _M_pi;
 _M_pi = __tmp;
      }

      long
      _M_get_use_count() const noexcept
      { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

      bool
      _M_less(const __weak_count& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

      bool
      _M_less(const __shared_count<_Lp>& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }


      friend inline bool
      operator==(const __weak_count& __a, const __weak_count& __b) noexcept
      { return __a._M_pi == __b._M_pi; }

    private:
      friend class __shared_count<_Lp>;

      template<typename> friend class _Sp_atomic;


      _Sp_counted_base<_Lp>* _M_pi;
    };


  template<_Lock_policy _Lp>
    inline
    __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
    : _M_pi(__r._M_pi)
    {
      if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow())
 __throw_bad_weak_ptr();
    }


  template<_Lock_policy _Lp>
    inline
    __shared_count<_Lp>::
    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept
    : _M_pi(__r._M_pi)
    {
      if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
    }





  template<typename _Yp_ptr, typename _Tp_ptr>
    struct __sp_compatible_with
    : false_type
    { };

  template<typename _Yp, typename _Tp>
    struct __sp_compatible_with<_Yp*, _Tp*>
    : is_convertible<_Yp*, _Tp*>::type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
    : true_type
    { };


  template<typename _Up, size_t _Nm, typename _Yp, typename = void>
    struct __sp_is_constructible_arrN
    : false_type
    { };

  template<typename _Up, size_t _Nm, typename _Yp>
    struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
    : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
    { };


  template<typename _Up, typename _Yp, typename = void>
    struct __sp_is_constructible_arr
    : false_type
    { };

  template<typename _Up, typename _Yp>
    struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
    : is_convertible<_Yp(*)[], _Up(*)[]>::type
    { };


  template<typename _Tp, typename _Yp>
    struct __sp_is_constructible;


  template<typename _Up, size_t _Nm, typename _Yp>
    struct __sp_is_constructible<_Up[_Nm], _Yp>
    : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
    { };


  template<typename _Up, typename _Yp>
    struct __sp_is_constructible<_Up[], _Yp>
    : __sp_is_constructible_arr<_Up, _Yp>::type
    { };


  template<typename _Tp, typename _Yp>
    struct __sp_is_constructible
    : is_convertible<_Yp*, _Tp*>::type
    { };


  template<typename _Tp>
    [[__gnu__::__always_inline__]]
    inline _Tp*
    __shared_ptr_deref(_Tp* __p)
    {
      do { if (std::__is_constant_evaluated() && !bool(__p != nullptr)) std::__glibcxx_assert_fail(); } while (false);
      return __p;
    }


  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
      { return *std::__shared_ptr_deref(_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;
# 1411 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      element_type&
      operator[](ptrdiff_t __i) const noexcept
      {
 if constexpr (extent<_Tp>::value)
   do { if (std::__is_constant_evaluated() && !bool(__i < extent<_Tp>::value)) std::__glibcxx_assert_fail(); } while (false);
 return std::__shared_ptr_deref(_M_get())[__i];
      }
#pragma GCC diagnostic pop

    private:
      element_type*
      _M_get() const noexcept
      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
    };

  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    : public __shared_ptr_access<_Tp, _Lp>
    {
    public:
      using element_type = typename remove_extent<_Tp>::type;

    private:

      template<typename _Yp>
 using _SafeConv
   = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;


      template<typename _Yp, typename _Res = void>
 using _Compatible = typename
   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;


      template<typename _Yp>
 using _Assignable = _Compatible<_Yp, __shared_ptr&>;


      template<typename _Yp, typename _Del, typename _Res = void,
        typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
 using _UniqCompatible = __enable_if_t<__and_<
   __sp_compatible_with<_Yp*, _Tp*>,
   is_convertible<_Ptr, element_type*>,
   is_move_constructible<_Del>
   >::value, _Res>;


      template<typename _Yp, typename _Del>
 using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

    public:


      using weak_type = __weak_ptr<_Tp, _Lp>;


      constexpr __shared_ptr() noexcept
      : _M_ptr(0), _M_refcount()
      { }

      template<typename _Yp, typename = _SafeConv<_Yp>>
 explicit
 __shared_ptr(_Yp* __p)
 : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
 {
   static_assert( !is_void<_Yp>::value, "incomplete type" );
   static_assert( sizeof(_Yp) > 0, "incomplete type" );
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Deleter>
 __shared_ptr(nullptr_t __p, _Deleter __d)
 : _M_ptr(0), _M_refcount(__p, std::move(__d))
 { }

      template<typename _Deleter, typename _Alloc>
        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
 { }


      template<typename _Yp>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount(__r._M_refcount)
 { }


      template<typename _Yp>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = nullptr;
 }

      __shared_ptr(const __shared_ptr&) noexcept = default;
      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
      ~__shared_ptr() = default;

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __shared_ptr(__shared_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount()
      {
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = nullptr;
      }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = nullptr;
 }

      template<typename _Yp, typename = _Compatible<_Yp>>
 explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
 : _M_refcount(__r._M_refcount)
 {


   _M_ptr = __r._M_ptr;
 }


      template<typename _Yp, typename _Del,
        typename = _UniqCompatible<_Yp, _Del>>
 __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : _M_ptr(__r.get()), _M_refcount()
 {
   auto __raw = std::__to_address(__r.get());
   _M_refcount = __shared_count<_Lp>(std::move(__r));
   _M_enable_shared_from_this_with(__raw);
 }
# 1592 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop


      constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r._M_ptr;
   _M_refcount = __r._M_refcount;
   return *this;
 }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp>
 _Assignable<_Yp>
 operator=(auto_ptr<_Yp>&& __r)
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }
#pragma GCC diagnostic pop


      __shared_ptr&
      operator=(__shared_ptr&& __r) noexcept
      {
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
      }

      template<class _Yp>
 _Assignable<_Yp>
 operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }

      template<typename _Yp, typename _Del>
 _UniqAssignable<_Yp, _Del>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }

      void
      reset() noexcept
      { __shared_ptr().swap(*this); }

      template<typename _Yp>
 _SafeConv<_Yp>
 reset(_Yp* __p)
 {

   do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) std::__glibcxx_assert_fail(); } while (false);
   __shared_ptr(__p).swap(*this);
 }

      template<typename _Yp, typename _Deleter>
 _SafeConv<_Yp>
 reset(_Yp* __p, _Deleter __d)
 { __shared_ptr(__p, std::move(__d)).swap(*this); }

      template<typename _Yp, typename _Deleter, typename _Alloc>
 _SafeConv<_Yp>
 reset(_Yp* __p, _Deleter __d, _Alloc __a)
        { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }


      element_type*
      get() const noexcept
      { return _M_ptr; }


      explicit operator bool() const noexcept
      { return _M_ptr != nullptr; }


      bool
      unique() const noexcept
      { return _M_refcount._M_unique(); }


      long
      use_count() const noexcept
      { return _M_refcount._M_get_use_count(); }


      void
      swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
      {
 std::swap(_M_ptr, __other._M_ptr);
 _M_refcount._M_swap(__other._M_refcount);
      }
# 1704 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
      template<typename _Tp1>
 bool
 owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }


    protected:

      template<typename _Alloc, typename... _Args>
 __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
 { _M_enable_shared_from_this_with(_M_ptr); }

      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
        typename... _Args>
 friend __shared_ptr<_Tp1, _Lp1>
 __allocate_shared(const _Alloc& __a, _Args&&... __args);



      template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
 __shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
       _Init __init = nullptr)
 : _M_ptr(), _M_refcount(_M_ptr, __a, __init)
 { }




      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept
      : _M_refcount(__r._M_refcount, std::nothrow)
      {
 _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
      }

      friend class __weak_ptr<_Tp, _Lp>;

    private:

      template<typename _Yp>
 using __esft_base_t = decltype(__enable_shared_from_this_base(
       std::declval<const __shared_count<_Lp>&>(),
       std::declval<_Yp*>()));


      template<typename _Yp, typename = void>
 struct __has_esft_base
 : false_type { };

      template<typename _Yp>
 struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
 : __not_<is_array<_Tp>> { };

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp* __p) noexcept
 {
   if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
     __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
 }

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<!__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp*) noexcept
 { }

      void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_refcount._M_get_deleter(__ti); }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

      template<typename _Del, typename _Tp1>
 friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;


      friend _Sp_atomic<shared_ptr<_Tp>>;





      element_type* _M_ptr;
      __shared_count<_Lp> _M_refcount;
    };



  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return __a.get() == __b.get(); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !__a; }


  template<typename _Tp, typename _Up, _Lock_policy _Lp>
    inline strong_ordering
    operator<=>(const __shared_ptr<_Tp, _Lp>& __a,
  const __shared_ptr<_Up, _Lp>& __b) noexcept
    { return compare_three_way()(__a.get(), __b.get()); }

  template<typename _Tp, _Lock_policy _Lp>
    inline strong_ordering
    operator<=>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    {
      using pointer = typename __shared_ptr<_Tp, _Lp>::element_type*;
      return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
    }
# 1925 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }
# 1937 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 2019 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_base.h" 3
      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 : _M_refcount(__r._M_refcount)
        { _M_ptr = __r.lock().get(); }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __weak_ptr(__weak_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
        { __r._M_ptr = nullptr; }

      __weak_ptr&
      operator=(const __weak_ptr& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = __r._M_refcount;
   return *this;
 }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r._M_ptr;
   _M_refcount = __r._M_refcount;
   return *this;
 }

      __weak_ptr&
      operator=(__weak_ptr&& __r) noexcept
      {
 __weak_ptr(std::move(__r)).swap(*this);
 return *this;
      }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = std::move(__r._M_refcount);
   __r._M_ptr = nullptr;
   return *this;
 }

      __shared_ptr<_Tp, _Lp>
      lock() const noexcept
      { return __shared_ptr<_Tp, _Lp>(*this, std::nothrow); }

      long
      use_count() const noexcept
      { return _M_refcount._M_get_use_count(); }

      bool
      expired() const noexcept
      { return _M_refcount._M_get_use_count() == 0; }

      template<typename _Tp1>
 bool
 owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      void
      reset() noexcept
      { __weak_ptr().swap(*this); }

      void
      swap(__weak_ptr& __s) noexcept
      {
 std::swap(_M_ptr, __s._M_ptr);
 _M_refcount._M_swap(__s._M_refcount);
      }

    private:

      void
      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
      {
 if (use_count() == 0)
   {
     _M_ptr = __ptr;
     _M_refcount = __refcount;
   }
      }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
      friend class __enable_shared_from_this<_Tp, _Lp>;
      friend class enable_shared_from_this<_Tp>;

      friend _Sp_atomic<weak_ptr<_Tp>>;


      element_type* _M_ptr;
      __weak_count<_Lp> _M_refcount;
    };


  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename _Tp, typename _Tp1>
    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }
    };
#pragma GCC diagnostic pop

  template<>
    struct _Sp_owner_less<void, void>
    {
      template<typename _Tp, typename _Up>
 auto
 operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
 -> decltype(__lhs.owner_before(__rhs))
 { return __lhs.owner_before(__rhs); }

      using is_transparent = void;
    };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__shared_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
    { };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__weak_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
    { };


  template<typename _Tp, _Lock_policy _Lp>
    class __enable_shared_from_this
    {
    protected:
      constexpr __enable_shared_from_this() noexcept { }

      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

      __enable_shared_from_this&
      operator=(const __enable_shared_from_this&) noexcept
      { return *this; }

      ~__enable_shared_from_this() { }

    public:
      __shared_ptr<_Tp, _Lp>
      shared_from_this()
      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

      __shared_ptr<const _Tp, _Lp>
      shared_from_this() const
      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }


      __weak_ptr<_Tp, _Lp>
      weak_from_this() noexcept
      { return this->_M_weak_this; }

      __weak_ptr<const _Tp, _Lp>
      weak_from_this() const noexcept
      { return this->_M_weak_this; }


    private:
      template<typename _Tp1>
 void
 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
 { _M_weak_this._M_assign(__p, __n); }

      friend const __enable_shared_from_this*
      __enable_shared_from_this_base(const __shared_count<_Lp>&,
         const __enable_shared_from_this* __p)
      { return __p; }

      template<typename, _Lock_policy>
 friend class __shared_ptr;

      mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
    };

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename _Alloc, typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      static_assert(!is_array<_Tp>::value, "make_shared<T[]> not supported");

      return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __make_shared(_Args&&... __args)
    {
      typedef typename std::remove_const<_Tp>::type _Tp_nc;
      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
           std::forward<_Args>(__args)...);
    }


  template<typename _Tp, _Lock_policy _Lp>
    struct hash<__shared_ptr<_Tp, _Lp>>
    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
    {
      size_t
      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
      {
 return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
     __s.get());
      }
    };


}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
    inline std::basic_ostream<_Ch, _Tr>&
    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
        const __shared_ptr<_Tp, _Lp>& __p)
    {
      __os << __p.get();
      return __os;
    }

  template<typename _Del, typename _Tp, _Lock_policy _Lp>
    inline _Del*
    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }





  template<typename _Del, typename _Tp>
    inline _Del*
    get_deleter(const shared_ptr<_Tp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }





  template<typename _Tp>
    requires (!is_array_v<_Tp>)
    using _NonArray = _Tp;
# 118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires is_array_v<_Tp> && (extent_v<_Tp> == 0)
    using _UnboundedArray = _Tp;
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires (extent_v<_Tp> != 0)
    using _BoundedArray = _Tp;
# 141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires (!is_array_v<_Tp>) || (extent_v<_Tp> != 0)
    using _NotUnboundedArray = _Tp;
# 174 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
      template<typename... _Args>
 using _Constructible = typename enable_if<
   is_constructible<__shared_ptr<_Tp>, _Args...>::value
 >::type;

      template<typename _Arg>
 using _Assignable = typename enable_if<
   is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
 >::type;

    public:


      using element_type = typename __shared_ptr<_Tp>::element_type;




      using weak_type = weak_ptr<_Tp>;





      constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

      shared_ptr(const shared_ptr&) noexcept = default;







      template<typename _Yp, typename = _Constructible<_Yp*>>
 explicit
 shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
# 228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter,
        typename = _Constructible<_Yp*, _Deleter>>
 shared_ptr(_Yp* __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 246 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Deleter>
 shared_ptr(nullptr_t __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 265 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
 shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 285 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Deleter, typename _Alloc>
 shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp>
 shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(__r, __p) { }
# 337 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp>
 shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(std::move(__r), __p) { }
# 348 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
        : __shared_ptr<_Tp>(__r) { }






      shared_ptr(shared_ptr&& __r) noexcept
      : __shared_ptr<_Tp>(std::move(__r)) { }






      template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 378 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 explicit shared_ptr(const weak_ptr<_Yp>& __r)
 : __shared_ptr<_Tp>(__r) { }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
 shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop




      template<typename _Yp, typename _Del,
        typename = _Constructible<unique_ptr<_Yp, _Del>>>
 shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 411 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
      constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

      shared_ptr& operator=(const shared_ptr&) noexcept = default;

      template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(__r);
   return *this;
 }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp>
 _Assignable<auto_ptr<_Yp>>
 operator=(auto_ptr<_Yp>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }
#pragma GCC diagnostic pop


      shared_ptr&
      operator=(shared_ptr&& __r) noexcept
      {
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
      }

      template<class _Yp>
 _Assignable<shared_ptr<_Yp>>
 operator=(shared_ptr<_Yp>&& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

      template<typename _Yp, typename _Del>
 _Assignable<unique_ptr<_Yp, _Del>>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

    private:

      template<typename _Alloc, typename... _Args>
 shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
 { }

      template<typename _Yp, typename _Alloc, typename... _Args>
 friend shared_ptr<_NonArray<_Yp>>
 allocate_shared(const _Alloc&, _Args&&...);

      template<typename _Yp, typename... _Args>
 friend shared_ptr<_NonArray<_Yp>>
 make_shared(_Args&&...);



      template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
 shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
     _Init __init = nullptr)
 : __shared_ptr<_Tp>(__a, __init)
 { }

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared(const _Alloc&, size_t);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared(size_t);

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared(const _Alloc&, size_t, const remove_extent_t<_Yp>&);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared(size_t, const remove_extent_t<_Yp>&);

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_BoundedArray<_Yp>>
 allocate_shared(const _Alloc&);

      template<typename _Yp>
 friend shared_ptr<_BoundedArray<_Yp>>
 make_shared();

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_BoundedArray<_Yp>>
 allocate_shared(const _Alloc&, const remove_extent_t<_Yp>&);

      template<typename _Yp>
 friend shared_ptr<_BoundedArray<_Yp>>
 make_shared(const remove_extent_t<_Yp>&);


      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_NotUnboundedArray<_Yp>>
 allocate_shared_for_overwrite(const _Alloc&);

      template<typename _Yp>
 friend shared_ptr<_NotUnboundedArray<_Yp>>
 make_shared_for_overwrite();

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared_for_overwrite(const _Alloc&, size_t);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared_for_overwrite(size_t);




      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept
      : __shared_ptr<_Tp>(__r, std::nothrow) { }

      friend class weak_ptr<_Tp>;
    };


  template<typename _Tp>
    shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
  template<typename _Tp, typename _Del>
    shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;







  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return __a.get() == __b.get(); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return !__a; }


  template<typename _Tp, typename _Up>
    inline strong_ordering
    operator<=>(const shared_ptr<_Tp>& __a,
  const shared_ptr<_Up>& __b) noexcept
    { return compare_three_way()(__a.get(), __b.get()); }

  template<typename _Tp>
    inline strong_ordering
    operator<=>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    {
      using pointer = typename shared_ptr<_Tp>::element_type*;
      return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
    }
# 689 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    inline void
    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
    { __a.swap(__b); }




  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(__r, __p);
      return _Sp();
    }




  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }







  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    static_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   static_cast<typename _Sp::element_type*>(__r.get()));
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    const_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   const_cast<typename _Sp::element_type*>(__r.get()));
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(std::move(__r), __p);
      return _Sp();
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }
# 809 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp>
    class weak_ptr : public __weak_ptr<_Tp>
    {
      template<typename _Arg>
 using _Constructible = typename enable_if<
   is_constructible<__weak_ptr<_Tp>, _Arg>::value
 >::type;

      template<typename _Arg>
 using _Assignable = typename enable_if<
   is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
 >::type;

    public:
      constexpr weak_ptr() noexcept = default;

      template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 weak_ptr(const shared_ptr<_Yp>& __r) noexcept
 : __weak_ptr<_Tp>(__r) { }

      weak_ptr(const weak_ptr&) noexcept = default;

      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 weak_ptr(const weak_ptr<_Yp>& __r) noexcept
 : __weak_ptr<_Tp>(__r) { }

      weak_ptr(weak_ptr&&) noexcept = default;

      template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
 weak_ptr(weak_ptr<_Yp>&& __r) noexcept
 : __weak_ptr<_Tp>(std::move(__r)) { }

      weak_ptr&
      operator=(const weak_ptr& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<const weak_ptr<_Yp>&>
 operator=(const weak_ptr<_Yp>& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(__r);
   return *this;
 }

      template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(__r);
   return *this;
 }

      weak_ptr&
      operator=(weak_ptr&& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<weak_ptr<_Yp>>
 operator=(weak_ptr<_Yp>&& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

      shared_ptr<_Tp>
      lock() const noexcept
      { return shared_ptr<_Tp>(*this, std::nothrow); }
    };


  template<typename _Tp>
    weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;





  template<typename _Tp>
    inline void
    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
    { __a.swap(__b); }



  template<typename _Tp = void>
    struct owner_less;


  template<>
    struct owner_less<void> : _Sp_owner_less<void, void>
    { };


  template<typename _Tp>
    struct owner_less<shared_ptr<_Tp>>
    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
    { };


  template<typename _Tp>
    struct owner_less<weak_ptr<_Tp>>
    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
    { };






  template<typename _Tp>
    class enable_shared_from_this
    {
    protected:
      constexpr enable_shared_from_this() noexcept { }

      enable_shared_from_this(const enable_shared_from_this&) noexcept { }

      enable_shared_from_this&
      operator=(const enable_shared_from_this&) noexcept
      { return *this; }

      ~enable_shared_from_this() { }

    public:
      shared_ptr<_Tp>
      shared_from_this()
      { return shared_ptr<_Tp>(this->_M_weak_this); }

      shared_ptr<const _Tp>
      shared_from_this() const
      { return shared_ptr<const _Tp>(this->_M_weak_this); }






      weak_ptr<_Tp>
      weak_from_this() noexcept
      { return this->_M_weak_this; }

      weak_ptr<const _Tp>
      weak_from_this() const noexcept
      { return this->_M_weak_this; }



    private:
      template<typename _Tp1>
 void
 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
 { _M_weak_this._M_assign(__p, __n); }


      friend const enable_shared_from_this*
      __enable_shared_from_this_base(const __shared_count<>&,
         const enable_shared_from_this* __p)
      { return __p; }

      template<typename, _Lock_policy>
 friend class __shared_ptr;

      mutable weak_ptr<_Tp> _M_weak_this;
    };
# 986 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp, typename _Alloc, typename... _Args>
    inline shared_ptr<_NonArray<_Tp>>
    allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }
# 1001 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr.h" 3
  template<typename _Tp, typename... _Args>
    inline shared_ptr<_NonArray<_Tp>>
    make_shared(_Args&&... __args)
    {
      using _Alloc = allocator<void>;
      _Alloc __a;
      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }



  template<typename _Tp, typename _Alloc = allocator<void>>
    auto
    __make_shared_arr_tag(size_t __n, const _Alloc& __a = _Alloc()) noexcept
    {
      using _Up = remove_all_extents_t<_Tp>;
      using _UpAlloc = __alloc_rebind<_Alloc, _Up>;
      size_t __s = sizeof(remove_extent_t<_Tp>) / sizeof(_Up);
      if (__builtin_mul_overflow(__s, __n, &__n))
 std::__throw_bad_array_new_length();
      return _Sp_counted_array_base<_UpAlloc>{_UpAlloc(__a), __n};
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a));
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared(size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n));
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, size_t __n,
      const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a),
        std::__addressof(__u));
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared(size_t __n, const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n),
        std::__addressof(__u));
    }


  template<typename _Tp, typename _Alloc = allocator<void>>
    auto
    __make_shared_arrN_tag(const _Alloc& __a = _Alloc()) noexcept
    {
      using _Up = remove_all_extents_t<_Tp>;
      using _UpAlloc = __alloc_rebind<_Alloc, _Up>;
      size_t __n = sizeof(_Tp) / sizeof(_Up);
      return _Sp_counted_array_base<_UpAlloc>{_UpAlloc(__a), __n};
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_BoundedArray<_Tp>>
    allocate_shared(const _Alloc& __a)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a));
    }

  template<typename _Tp>
    inline shared_ptr<_BoundedArray<_Tp>>
    make_shared()
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>());
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_BoundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a),
        std::__addressof(__u));
    }

  template<typename _Tp>
    inline shared_ptr<_BoundedArray<_Tp>>
    make_shared(const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(),
        std::__addressof(__u));
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_NotUnboundedArray<_Tp>>
    allocate_shared_for_overwrite(const _Alloc& __a)
    {
      if constexpr (is_array_v<_Tp>)
 return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a),
          _Sp_overwrite_tag{});
      else
 {


   using _Alloc2 = __alloc_rebind<_Alloc, _Sp_overwrite_tag>;
   _Alloc2 __a2 = __a;
   return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc2>{__a2});
 }
    }

  template<typename _Tp>
    inline shared_ptr<_NotUnboundedArray<_Tp>>
    make_shared_for_overwrite()
    {
      if constexpr (is_array_v<_Tp>)
 return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(),
          _Sp_overwrite_tag{});
      else
 {
   using _Alloc = allocator<_Sp_overwrite_tag>;
   return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{{}});
 }
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared_for_overwrite(const _Alloc& __a, size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a),
        _Sp_overwrite_tag{});
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared_for_overwrite(size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n),
        _Sp_overwrite_tag{});
    }




  template<typename _Tp>
    struct hash<shared_ptr<_Tp>>
    : public __hash_base<size_t, shared_ptr<_Tp>>
    {
      size_t
      operator()(const shared_ptr<_Tp>& __s) const noexcept
      {
 return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
      }
    };


  template<typename _Tp>
    constexpr bool __is_shared_ptr = false;
  template<typename _Tp>
    constexpr bool __is_shared_ptr<shared_ptr<_Tp>> = true;






  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp>
      struct _Never_valueless_alt<std::shared_ptr<_Tp>>
      : std::true_type
      { };



    template<typename _Tp>
      struct _Never_valueless_alt<std::weak_ptr<_Tp>>
      : std::true_type
      { };
  }



}
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 1 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  struct _Sp_locker
  {
    _Sp_locker(const _Sp_locker&) = delete;
    _Sp_locker& operator=(const _Sp_locker&) = delete;


    explicit
    _Sp_locker(const void*) noexcept;
    _Sp_locker(const void*, const void*) noexcept;
    ~_Sp_locker();

  private:
    unsigned char _M_key1;
    unsigned char _M_key2;



  };
# 101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>*)
    {

      return __gthread_active_p() == 0;



    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
# 130 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_load(const shared_ptr<_Tp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
# 170 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
     __shared_ptr<_Tp, _Lp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
# 211 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
        memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
        __shared_ptr<_Tp, _Lp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
        memory_order_seq_cst);
    }
# 264 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    bool
    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
         shared_ptr<_Tp>* __v,
         shared_ptr<_Tp> __w,
         memory_order,
         memory_order)
    {
      shared_ptr<_Tp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<shared_ptr<_Tp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
       shared_ptr<_Tp>* __v,
       shared_ptr<_Tp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    bool
    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
         __shared_ptr<_Tp, _Lp>* __v,
         __shared_ptr<_Tp, _Lp> __w,
         memory_order,
         memory_order)
    {
      __shared_ptr<_Tp, _Lp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<__shared_ptr<_Tp, _Lp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
     __shared_ptr<_Tp, _Lp>* __v,
     __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }





  template<typename _Tp>
    struct atomic;







  template<typename _Tp>
    class _Sp_atomic
    {
      using value_type = _Tp;

      friend struct atomic<_Tp>;



      struct _Atomic_count
      {

 using __count_type = decltype(_Tp::_M_refcount);
 using uintptr_t = long unsigned int;


 using pointer = decltype(__count_type::_M_pi);


 static_assert(alignof(remove_pointer_t<pointer>) > 1);

 constexpr _Atomic_count() noexcept = default;

 explicit
 _Atomic_count(__count_type&& __c) noexcept
 : _M_val(reinterpret_cast<uintptr_t>(__c._M_pi))
 {
   __c._M_pi = nullptr;
 }

 ~_Atomic_count()
 {
   auto __val = _M_val.load(memory_order_relaxed);
                                       ;
   do { if (std::__is_constant_evaluated() && !bool(!(__val & _S_lock_bit))) std::__glibcxx_assert_fail(); } while (false);
   if (auto __pi = reinterpret_cast<pointer>(__val))
     {
       if constexpr (__is_shared_ptr<_Tp>)
  __pi->_M_release();
       else
  __pi->_M_weak_release();
     }
 }

 _Atomic_count(const _Atomic_count&) = delete;
 _Atomic_count& operator=(const _Atomic_count&) = delete;



 pointer
 lock(memory_order __o) const noexcept
 {


   auto __current = _M_val.load(memory_order_relaxed);
   while (__current & _S_lock_bit)
     {

       __detail::__thread_relax();

       __current = _M_val.load(memory_order_relaxed);
     }

                                        ;

   while (!_M_val.compare_exchange_strong(__current,
       __current | _S_lock_bit,
       __o,
       memory_order_relaxed))
     {
                                                   ;

       __detail::__thread_relax();

       __current = __current & ~_S_lock_bit;
                                            ;
     }
                                      ;
   return reinterpret_cast<pointer>(__current);
 }


 void
 unlock(memory_order __o) const noexcept
 {
                                          ;
   _M_val.fetch_sub(1, __o);
                                           ;
 }



 void
 _M_swap_unlock(__count_type& __c, memory_order __o) noexcept
 {
   if (__o != memory_order_seq_cst)
     __o = memory_order_release;
   auto __x = reinterpret_cast<uintptr_t>(__c._M_pi);
                                          ;
   __x = _M_val.exchange(__x, __o);
                                           ;
   __c._M_pi = reinterpret_cast<pointer>(__x & ~_S_lock_bit);
 }



 void
 _M_wait_unlock(memory_order __o) const noexcept
 {
                                          ;
   auto __v = _M_val.fetch_sub(1, memory_order_relaxed);
                                           ;
   _M_val.wait(__v & ~_S_lock_bit, __o);
 }

 void
 notify_one() noexcept
 {
                                          ;
   _M_val.notify_one();
                                           ;
 }

 void
 notify_all() noexcept
 {
                                          ;
   _M_val.notify_all();
                                           ;
 }


      private:
 mutable __atomic_base<uintptr_t> _M_val{0};
 static constexpr uintptr_t _S_lock_bit{1};
      };

      typename _Tp::element_type* _M_ptr = nullptr;
      _Atomic_count _M_refcount;

      static typename _Atomic_count::pointer
      _S_add_ref(typename _Atomic_count::pointer __p)
      {
 if (__p)
   {
     if constexpr (__is_shared_ptr<_Tp>)
       __p->_M_add_ref_copy();
     else
       __p->_M_weak_add_ref();
   }
 return __p;
      }

      constexpr _Sp_atomic() noexcept = default;

      explicit
      _Sp_atomic(value_type __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
      { }

      ~_Sp_atomic() = default;

      _Sp_atomic(const _Sp_atomic&) = delete;
      void operator=(const _Sp_atomic&) = delete;

      value_type
      load(memory_order __o) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__o != memory_order_release && __o != memory_order_acq_rel)) std::__glibcxx_assert_fail(); } while (false);



 if (__o != memory_order_seq_cst)
   __o = memory_order_acquire;

 value_type __ret;
 auto __pi = _M_refcount.lock(__o);
 __ret._M_ptr = _M_ptr;
 __ret._M_refcount._M_pi = _S_add_ref(__pi);
 _M_refcount.unlock(memory_order_relaxed);
 return __ret;
      }

      void
      swap(value_type& __r, memory_order __o) noexcept
      {
 _M_refcount.lock(memory_order_acquire);
 std::swap(_M_ptr, __r._M_ptr);
 _M_refcount._M_swap_unlock(__r._M_refcount, __o);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 bool __result = true;
 auto __pi = _M_refcount.lock(memory_order_acquire);
 if (_M_ptr == __expected._M_ptr
       && __pi == __expected._M_refcount._M_pi)
   {
     _M_ptr = __desired._M_ptr;
     _M_refcount._M_swap_unlock(__desired._M_refcount, __o);
   }
 else
   {
     _Tp __sink = std::move(__expected);
     __expected._M_ptr = _M_ptr;
     __expected._M_refcount._M_pi = _S_add_ref(__pi);
     _M_refcount.unlock(__o2);
     __result = false;
   }
 return __result;
      }


      void
      wait(value_type __old, memory_order __o) const noexcept
      {
 auto __pi = _M_refcount.lock(memory_order_acquire);
 if (_M_ptr == __old._M_ptr && __pi == __old._M_refcount._M_pi)
   _M_refcount._M_wait_unlock(__o);
 else
   _M_refcount.unlock(memory_order_relaxed);
      }

      void
      notify_one() noexcept
      {
 _M_refcount.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_refcount.notify_all();
      }

    };

  template<typename _Tp>
    struct atomic<shared_ptr<_Tp>>
    {
    public:
      using value_type = shared_ptr<_Tp>;

      static constexpr bool is_always_lock_free = false;

      bool
      is_lock_free() const noexcept
      { return false; }

      constexpr atomic() noexcept = default;



      constexpr atomic(nullptr_t) noexcept : atomic() { }

      atomic(shared_ptr<_Tp> __r) noexcept
      : _M_impl(std::move(__r))
      { }

      atomic(const atomic&) = delete;
      void operator=(const atomic&) = delete;

      shared_ptr<_Tp>
      load(memory_order __o = memory_order_seq_cst) const noexcept
      { return _M_impl.load(__o); }

      operator shared_ptr<_Tp>() const noexcept
      { return _M_impl.load(memory_order_seq_cst); }

      void
      store(shared_ptr<_Tp> __desired,
     memory_order __o = memory_order_seq_cst) noexcept
      { _M_impl.swap(__desired, __o); }

      void
      operator=(shared_ptr<_Tp> __desired) noexcept
      { _M_impl.swap(__desired, memory_order_seq_cst); }



      void
      operator=(nullptr_t) noexcept
      { store(nullptr); }

      shared_ptr<_Tp>
      exchange(shared_ptr<_Tp> __desired,
        memory_order __o = memory_order_seq_cst) noexcept
      {
 _M_impl.swap(__desired, __o);
 return __desired;
      }

      bool
      compare_exchange_strong(shared_ptr<_Tp>& __expected,
         shared_ptr<_Tp> __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 return _M_impl.compare_exchange_strong(__expected, __desired, __o, __o2);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o = memory_order_seq_cst) noexcept
      {
 memory_order __o2;
 switch (__o)
 {
 case memory_order_acq_rel:
   __o2 = memory_order_acquire;
   break;
 case memory_order_release:
   __o2 = memory_order_relaxed;
   break;
 default:
   __o2 = __o;
 }
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o, memory_order __o2) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o = memory_order_seq_cst) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired), __o);
      }


      void
      wait(value_type __old,
    memory_order __o = memory_order_seq_cst) const noexcept
      {
 _M_impl.wait(std::move(__old), __o);
      }

      void
      notify_one() noexcept
      {
 _M_impl.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_impl.notify_all();
      }


    private:
      _Sp_atomic<shared_ptr<_Tp>> _M_impl;
    };

  template<typename _Tp>
    struct atomic<weak_ptr<_Tp>>
    {
    public:
      using value_type = weak_ptr<_Tp>;

      static constexpr bool is_always_lock_free = false;

      bool
      is_lock_free() const noexcept
      { return false; }

      constexpr atomic() noexcept = default;

      atomic(weak_ptr<_Tp> __r) noexcept
     : _M_impl(move(__r))
      { }

      atomic(const atomic&) = delete;
      void operator=(const atomic&) = delete;

      weak_ptr<_Tp>
      load(memory_order __o = memory_order_seq_cst) const noexcept
      { return _M_impl.load(__o); }

      operator weak_ptr<_Tp>() const noexcept
      { return _M_impl.load(memory_order_seq_cst); }

      void
      store(weak_ptr<_Tp> __desired,
     memory_order __o = memory_order_seq_cst) noexcept
      { _M_impl.swap(__desired, __o); }

      void
      operator=(weak_ptr<_Tp> __desired) noexcept
      { _M_impl.swap(__desired, memory_order_seq_cst); }

      weak_ptr<_Tp>
      exchange(weak_ptr<_Tp> __desired,
        memory_order __o = memory_order_seq_cst) noexcept
      {
 _M_impl.swap(__desired, __o);
 return __desired;
      }

      bool
      compare_exchange_strong(weak_ptr<_Tp>& __expected,
         weak_ptr<_Tp> __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 return _M_impl.compare_exchange_strong(__expected, __desired, __o, __o2);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o = memory_order_seq_cst) noexcept
      {
 memory_order __o2;
 switch (__o)
 {
 case memory_order_acq_rel:
   __o2 = memory_order_acquire;
   break;
 case memory_order_release:
   __o2 = memory_order_relaxed;
   break;
 default:
   __o2 = __o;
 }
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o, memory_order __o2) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o = memory_order_seq_cst) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired), __o);
      }


      void
      wait(value_type __old,
    memory_order __o = memory_order_seq_cst) const noexcept
      {
 _M_impl.wait(std::move(__old), __o);
      }

      void
      notify_one() noexcept
      {
 _M_impl.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_impl.notify_all();
      }


    private:
      _Sp_atomic<weak_ptr<_Tp>> _M_impl;
    };




}
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } __attribute__ ((__deprecated__));

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 92 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 130 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 158 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 186 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) std::__glibcxx_assert_fail(); } while (false);
 return _M_ptr;
      }
# 216 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 230 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 245 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 270 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } __attribute__ ((__deprecated__ ("use '" "std::unique_ptr" "' instead")));



  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } __attribute__ ((__deprecated__));



  template<_Lock_policy _Lp>
  template<typename _Tp>
    inline
    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
    { __r.release(); }

  template<typename _Tp, _Lock_policy _Lp>
  template<typename _Tp1, typename>
    inline
    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : _M_ptr(__r.get()), _M_refcount()
    {

      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
      _Tp1* __tmp = __r.get();
      _M_refcount = __shared_count<_Lp>(std::move(__r));
      _M_enable_shared_from_this_with(__tmp);
    }

  template<typename _Tp>
  template<typename _Tp1, typename>
    inline
    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : __shared_ptr<_Tp>(std::move(__r)) { }


  template<typename _Tp, typename _Dp>
  template<typename _Up, typename>
    inline
    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
    : _M_t(__u.release(), deleter_type()) { }


#pragma GCC diagnostic pop


}
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_uninitialized.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_uninitialized.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algobase.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algobase.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Tp>
      constexpr inline bool __is_normal_iterator = false;

    template<typename _Iterator, typename _Container>
      constexpr inline bool
 __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
         _Container>> = true;

    template<typename _Tp>
      constexpr inline bool __is_reverse_iterator = false;

    template<typename _Iterator>
      constexpr inline bool
 __is_reverse_iterator<reverse_iterator<_Iterator>> = true;

    template<typename _Tp>
      constexpr inline bool __is_move_iterator = false;

    template<typename _Iterator>
      constexpr inline bool
 __is_move_iterator<move_iterator<_Iterator>> = true;
  }
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algobase.h" 3
  struct __equal_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {


 if constexpr (__detail::__is_normal_iterator<_Iter1>
        && same_as<_Iter1, _Sent1>)
   return (*this)(__first1.base(), __last1.base(),
    std::move(__first2), std::move(__last2),
    std::move(__pred),
    std::move(__proj1), std::move(__proj2));
 else if constexpr (__detail::__is_normal_iterator<_Iter2>
      && same_as<_Iter2, _Sent2>)
   return (*this)(std::move(__first1), std::move(__last1),
    __first2.base(), __last2.base(),
    std::move(__pred),
    std::move(__proj1), std::move(__proj2));
 else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
      && sized_sentinel_for<_Sent2, _Iter2>)
   {
     auto __d1 = ranges::distance(__first1, __last1);
     auto __d2 = ranges::distance(__first2, __last2);
     if (__d1 != __d2)
       return false;

     using _ValueType1 = iter_value_t<_Iter1>;
     constexpr bool __use_memcmp
       = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
   && __memcmpable<_Iter1, _Iter2>::__value
   && is_same_v<_Pred, ranges::equal_to>
   && is_same_v<_Proj1, identity>
   && is_same_v<_Proj2, identity>);
     if constexpr (__use_memcmp)
       {
  if (const size_t __len = (__last1 - __first1))
    return !std::__memcmp(__first1, __first2, __len);
  return true;
       }
     else
       {
  for (; __first1 != __last1; ++__first1, (void)++__first2)
    if (!(bool)std::__invoke(__pred,
        std::__invoke(__proj1, *__first1),
        std::__invoke(__proj2, *__first2)))
      return false;
  return true;
       }
   }
 else
   {
     for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
       if (!(bool)std::__invoke(__pred,
           std::__invoke(__proj1, *__first1),
           std::__invoke(__proj2, *__first2)))
  return false;
     return __first1 == __last1 && __first2 == __last2;
   }
      }

    template<input_range _Range1, input_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr bool
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {


 if constexpr (sized_range<_Range1>)
   if constexpr (sized_range<_Range2>)
     if (ranges::distance(__r1) != ranges::distance(__r2))
       return false;

 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __equal_fn equal{};

namespace __detail
{
  template<bool _IsMove, typename _OutIter, typename _InIter>
    [[__gnu__::__always_inline__]]
    constexpr void
    __assign_one(_OutIter& __out, _InIter& __in)
    {
      if constexpr (_IsMove)
 *__out = ranges::iter_move(__in);
      else
 *__out = *__in;
    }
}

  template<typename _Iter, typename _Out>
    struct in_out_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Out out;

      template<typename _Iter2, typename _Out2>
 requires convertible_to<const _Iter&, _Iter2>
   && convertible_to<const _Out&, _Out2>
 constexpr
 operator in_out_result<_Iter2, _Out2>() const &
 { return {in, out}; }

      template<typename _Iter2, typename _Out2>
 requires convertible_to<_Iter, _Iter2>
   && convertible_to<_Out, _Out2>
 constexpr
 operator in_out_result<_Iter2, _Out2>() &&
 { return {std::move(in), std::move(out)}; }
    };

  template<typename _Iter, typename _Out>
    using copy_result = in_out_result<_Iter, _Out>;

  template<typename _Iter, typename _Out>
    using move_result = in_out_result<_Iter, _Out>;

  template<typename _Iter1, typename _Iter2>
    using move_backward_result = in_out_result<_Iter1, _Iter2>;

  template<typename _Iter1, typename _Iter2>
    using copy_backward_result = in_out_result<_Iter1, _Iter2>;

  template<bool _IsMove,
    bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
    bidirectional_iterator _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_backward_result<_Iter, _Out>,
         copy_backward_result<_Iter, _Out>>
    __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);

  template<bool _IsMove,
    input_iterator _Iter, sentinel_for<_Iter> _Sent,
    weakly_incrementable _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_result<_Iter, _Out>,
         copy_result<_Iter, _Out>>
    __copy_or_move(_Iter __first, _Sent __last, _Out __result)
    {


      using __detail::__is_move_iterator;
      using __detail::__is_reverse_iterator;
      using __detail::__is_normal_iterator;
      if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in, __out]
     = ranges::__copy_or_move<true>(std::move(__first).base(),
        std::move(__last).base(),
        std::move(__result));
   return {move_iterator{std::move(__in)}, std::move(__out)};
 }
      else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
    && __is_reverse_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
             std::move(__first).base(),
             std::move(__result).base());
   return {reverse_iterator{std::move(__in)},
    reverse_iterator{std::move(__out)}};
 }
      else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
           std::move(__result));
   return {decltype(__first){__in}, std::move(__out)};
 }
      else if constexpr (__is_normal_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(std::move(__first), __last, __result.base());
   return {std::move(__in), decltype(__result){__out}};
 }
      else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 {
   if (!std::__is_constant_evaluated())
     {
       if constexpr (__memcpyable<_Out, _Iter>::__value)
  {
    using _ValueTypeI = iter_value_t<_Iter>;
    auto __num = __last - __first;
    if (__num > 1) [[likely]]
      __builtin_memmove(__result, __first,
          sizeof(_ValueTypeI) * __num);
    else if (__num == 1)
      __detail::__assign_one<_IsMove>(__result, __first);
    return {__first + __num, __result + __num};
  }
     }

   for (auto __n = __last - __first; __n > 0; --__n)
     {
       __detail::__assign_one<_IsMove>(__result, __first);
       ++__first;
       ++__result;
     }
   return {std::move(__first), std::move(__result)};
 }
      else
 {
   while (__first != __last)
     {
       __detail::__assign_one<_IsMove>(__result, __first);
       ++__first;
       ++__result;
     }
   return {std::move(__first), std::move(__result)};
 }
    }

  struct __copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result) const
      {
 return ranges::__copy_or_move<false>(std::move(__first),
          std::move(__last),
          std::move(__result));
      }

    template<input_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __copy_fn copy{};

  struct __move_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_movable<_Iter, _Out>
      constexpr move_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result) const
      {
 return ranges::__copy_or_move<true>(std::move(__first),
         std::move(__last),
         std::move(__result));
      }

    template<input_range _Range, weakly_incrementable _Out>
      requires indirectly_movable<iterator_t<_Range>, _Out>
      constexpr move_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __move_fn move{};

  template<bool _IsMove,
    bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
    bidirectional_iterator _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_backward_result<_Iter, _Out>,
         copy_backward_result<_Iter, _Out>>
    __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
    {


      using __detail::__is_reverse_iterator;
      using __detail::__is_normal_iterator;
      if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
      && __is_reverse_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
           std::move(__first).base(),
           std::move(__result).base());
   return {reverse_iterator{std::move(__in)},
    reverse_iterator{std::move(__out)}};
 }
      else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(__first.base(),
             __last.base(),
             std::move(__result));
   return {decltype(__first){__in}, std::move(__out)};
 }
      else if constexpr (__is_normal_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
             std::move(__last),
             __result.base());
   return {std::move(__in), decltype(__result){__out}};
 }
      else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 {
   if (!std::__is_constant_evaluated())
     {
       if constexpr (__memcpyable<_Out, _Iter>::__value)
  {
    using _ValueTypeI = iter_value_t<_Iter>;
    auto __num = __last - __first;
    __result -= __num;
    if (__num > 1) [[likely]]
      __builtin_memmove(__result, __first,
          sizeof(_ValueTypeI) * __num);
    else if (__num == 1)
      __detail::__assign_one<_IsMove>(__result, __first);
    return {__first + __num, __result};
  }
     }

   auto __lasti = ranges::next(__first, __last);
   auto __tail = __lasti;

   for (auto __n = __last - __first; __n > 0; --__n)
     {
       --__tail;
       --__result;
       __detail::__assign_one<_IsMove>(__result, __tail);
     }
   return {std::move(__lasti), std::move(__result)};
 }
      else
 {
   auto __lasti = ranges::next(__first, __last);
   auto __tail = __lasti;

   while (__first != __tail)
     {
       --__tail;
       --__result;
       __detail::__assign_one<_IsMove>(__result, __tail);
     }
   return {std::move(__lasti), std::move(__result)};
 }
    }

  struct __copy_backward_fn
  {
    template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      bidirectional_iterator _Iter2>
      requires indirectly_copyable<_Iter1, _Iter2>
      constexpr copy_backward_result<_Iter1, _Iter2>
      operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
      {
 return ranges::__copy_or_move_backward<false>(std::move(__first),
            std::move(__last),
            std::move(__result));
      }

    template<bidirectional_range _Range, bidirectional_iterator _Iter>
      requires indirectly_copyable<iterator_t<_Range>, _Iter>
      constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
      operator()(_Range&& __r, _Iter __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __copy_backward_fn copy_backward{};

  struct __move_backward_fn
  {
    template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      bidirectional_iterator _Iter2>
      requires indirectly_movable<_Iter1, _Iter2>
      constexpr move_backward_result<_Iter1, _Iter2>
      operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
      {
 return ranges::__copy_or_move_backward<true>(std::move(__first),
           std::move(__last),
           std::move(__result));
      }

    template<bidirectional_range _Range, bidirectional_iterator _Iter>
      requires indirectly_movable<iterator_t<_Range>, _Iter>
      constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
      operator()(_Range&& __r, _Iter __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __move_backward_fn move_backward{};

  template<typename _Iter, typename _Out>
    using copy_n_result = in_out_result<_Iter, _Out>;

  struct __copy_n_fn
  {
    template<input_iterator _Iter, weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr copy_n_result<_Iter, _Out>
      operator()(_Iter __first, iter_difference_t<_Iter> __n,
   _Out __result) const
      {
 if constexpr (random_access_iterator<_Iter>)
   {
     if (__n > 0)
       return ranges::copy(__first, __first + __n, std::move(__result));
   }
 else
   {
     for (; __n > 0; --__n, (void)++__result, (void)++__first)
       *__result = *__first;
   }
 return {std::move(__first), std::move(__result)};
      }
  };

  inline constexpr __copy_n_fn copy_n{};

  struct __fill_n_fn
  {
    template<typename _Out,
      typename _Tp >
      requires output_iterator<_Out, const _Tp&>
      constexpr _Out
      operator()(_Out __first, iter_difference_t<_Out> __n,
   const _Tp& __value) const
      {


 if (__n <= 0)
   return __first;

 if constexpr (is_scalar_v<_Tp>)
   {

     if constexpr (is_pointer_v<_Out>

     && __is_byte<remove_pointer_t<_Out>>::__value
     && integral<_Tp>)
       {
  if (!std::__is_constant_evaluated())
    {
      __builtin_memset(__first,
         static_cast<unsigned char>(__value),
         __n);
      return __first + __n;
    }
       }

     const auto __tmp = __value;
     for (; __n > 0; --__n, (void)++__first)
       *__first = __tmp;
     return __first;
   }
 else
   {
     for (; __n > 0; --__n, (void)++__first)
       *__first = __value;
     return __first;
   }
      }
  };

  inline constexpr __fill_n_fn fill_n{};

  struct __fill_fn
  {
    template<typename _Out,
      sentinel_for<_Out> _Sent,
      typename _Tp >
      requires output_iterator<_Out, const _Tp&>
      constexpr _Out
      operator()(_Out __first, _Sent __last, const _Tp& __value) const
      {


 if constexpr (sized_sentinel_for<_Sent, _Out>)
   {
     const auto __len = __last - __first;
     return ranges::fill_n(std::move(__first), __len, __value);
   }
 else if constexpr (is_scalar_v<_Tp>)
   {
     const auto __tmp = __value;
     for (; __first != __last; ++__first)
       *__first = __tmp;
     return __first;
   }
 else
   {
     for (; __first != __last; ++__first)
       *__first = __value;
     return __first;
   }
      }

    template<typename _Range,
      typename _Tp >
      requires output_range<_Range, const _Tp&>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, const _Tp& __value) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r), __value);
      }
  };

  inline constexpr __fill_fn fill{};
}

}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_uninitialized.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Tp>
      constexpr void*
      __voidify(_Tp& __obj) noexcept
      {
 return const_cast<void*>
   (static_cast<const volatile void*>(std::__addressof(__obj)));
      }

    template<typename _Iter>
      concept __nothrow_input_iterator
 = (input_iterator<_Iter>
    && is_lvalue_reference_v<iter_reference_t<_Iter>>
    && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
        iter_value_t<_Iter>>);

    template<typename _Sent, typename _Iter>
      concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>;

    template<typename _Range>
      concept __nothrow_input_range
 = (range<_Range>
    && __nothrow_input_iterator<iterator_t<_Range>>
    && __nothrow_sentinel<sentinel_t<_Range>, iterator_t<_Range>>);

    template<typename _Iter>
      concept __nothrow_forward_iterator
 = (__nothrow_input_iterator<_Iter>
    && forward_iterator<_Iter>
    && __nothrow_sentinel<_Iter, _Iter>);

    template<typename _Range>
      concept __nothrow_forward_range
 = (__nothrow_input_range<_Range>
    && __nothrow_forward_iterator<iterator_t<_Range>>);
  }

  struct __destroy_fn
  {
    template<__detail::__nothrow_input_iterator _Iter,
      __detail::__nothrow_sentinel<_Iter> _Sent>
      requires destructible<iter_value_t<_Iter>>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last) const noexcept;

    template<__detail::__nothrow_input_range _Range>
      requires destructible<range_value_t<_Range>>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const noexcept;
  };

  inline constexpr __destroy_fn destroy{};

  namespace __detail
  {
    template<typename _Iter>
      requires destructible<iter_value_t<_Iter>>
      struct _DestroyGuard
      {
      private:
 _Iter _M_first;
 const _Iter* _M_cur;

      public:
 constexpr
 explicit
 _DestroyGuard(const _Iter& __iter)
   : _M_first(__iter), _M_cur(std::__addressof(__iter))
 { }

 constexpr
 void
 release() noexcept
 { _M_cur = nullptr; }

 constexpr
 ~_DestroyGuard()
 {
   if (_M_cur != nullptr)
     ranges::destroy(std::move(_M_first), *_M_cur);
 }
      };

    template<typename _Iter>
      requires destructible<iter_value_t<_Iter>>
 && is_trivially_destructible_v<iter_value_t<_Iter>>
      struct _DestroyGuard<_Iter>
      {
 constexpr
 explicit
 _DestroyGuard(const _Iter&)
 { }

 constexpr
 void
 release() noexcept
 { }
      };
  }

  struct __uninitialized_default_construct_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter,
      __detail::__nothrow_sentinel<_Iter> _Sent>
      requires default_initializable<iter_value_t<_Iter>>

      _Iter
      operator()(_Iter __first, _Sent __last) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_default_constructible_v<_ValueType>)
   return ranges::next(__first, __last);
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __first != __last; ++__first)
       ::new (__detail::__voidify(*__first)) _ValueType;
     __guard.release();
     return __first;
   }
      }

    template<__detail::__nothrow_forward_range _Range>
      requires default_initializable<range_value_t<_Range>>

      borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r));
      }
  };

  inline constexpr __uninitialized_default_construct_fn
    uninitialized_default_construct{};

  struct __uninitialized_default_construct_n_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter>
      requires default_initializable<iter_value_t<_Iter>>

      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_default_constructible_v<_ValueType>)
   return ranges::next(__first, __n);
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __n > 0; ++__first, (void) --__n)
       ::new (__detail::__voidify(*__first)) _ValueType;
     __guard.release();
     return __first;
   }
      }
  };

  inline constexpr __uninitialized_default_construct_n_fn
    uninitialized_default_construct_n;

  struct __uninitialized_value_construct_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter,
      __detail::__nothrow_sentinel<_Iter> _Sent>
      requires default_initializable<iter_value_t<_Iter>>

      _Iter
      operator()(_Iter __first, _Sent __last) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_default_constructible_v<_ValueType>
        && is_trivially_copy_assignable_v<_ValueType>)
   return ranges::fill(__first, __last, _ValueType());
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __first != __last; ++__first)
       ::new (__detail::__voidify(*__first)) _ValueType();
     __guard.release();
     return __first;
   }
      }

    template<__detail::__nothrow_forward_range _Range>
      requires default_initializable<range_value_t<_Range>>

      borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r));
      }
  };

  inline constexpr __uninitialized_value_construct_fn
    uninitialized_value_construct{};

  struct __uninitialized_value_construct_n_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter>
      requires default_initializable<iter_value_t<_Iter>>

      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_default_constructible_v<_ValueType>
        && is_trivially_copy_assignable_v<_ValueType>)
   return ranges::fill_n(__first, __n, _ValueType());
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __n > 0; ++__first, (void) --__n)
       ::new (__detail::__voidify(*__first)) _ValueType();
     __guard.release();
     return __first;
   }
      }
  };

  inline constexpr __uninitialized_value_construct_n_fn
    uninitialized_value_construct_n;

  template<typename _Iter, typename _Out>
    using uninitialized_copy_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
      __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _OSent>
      requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>

      uninitialized_copy_result<_Iter, _Out>
      operator()(_Iter __ifirst, _ISent __ilast,
   _Out __ofirst, _OSent __olast) const
      {
 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
 if constexpr (sized_sentinel_for<_ISent, _Iter>
        && sized_sentinel_for<_OSent, _Out>
        && is_trivially_constructible_v<_OutType, iter_reference_t<_Iter>>
        && is_trivially_default_constructible_v<_OutType>
        && is_trivially_assignable_v<_OutType&,
       iter_reference_t<_Iter>>)
   {
     auto __d = __ilast - __ifirst;
     if (auto __d2 = __olast - __ofirst; __d2 < __d)
       __d = static_cast<iter_difference_t<_Iter>>(__d2);
     return ranges::copy_n(std::move(__ifirst), __d, __ofirst);
   }
 else
   {
     auto __guard = __detail::_DestroyGuard(__ofirst);
     for (; __ifirst != __ilast && __ofirst != __olast;
   ++__ofirst, (void)++__ifirst)
       ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
     __guard.release();
     return {std::move(__ifirst), __ofirst};
   }
      }

    template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
      requires constructible_from<range_value_t<_ORange>,
      range_reference_t<_IRange>>

      uninitialized_copy_result<borrowed_iterator_t<_IRange>,
    borrowed_iterator_t<_ORange>>
      operator()(_IRange&& __inr, _ORange&& __outr) const
      {
 return (*this)(ranges::begin(__inr), ranges::end(__inr),
         ranges::begin(__outr), ranges::end(__outr));
      }
  };

  inline constexpr __uninitialized_copy_fn uninitialized_copy{};

  template<typename _Iter, typename _Out>
    using uninitialized_copy_n_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_copy_n_fn
  {
    template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _Sent>
      requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>

      uninitialized_copy_n_result<_Iter, _Out>
      operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
   _Out __ofirst, _Sent __olast) const
      {
 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
 if constexpr (sized_sentinel_for<_Sent, _Out>
        && is_trivially_constructible_v<_OutType, iter_reference_t<_Iter>>
        && is_trivially_default_constructible_v<_OutType>
        && is_trivially_assignable_v<_OutType&,
       iter_reference_t<_Iter>>)
   {
     if (auto __d = __olast - __ofirst; __d < __n)
       __n = static_cast<iter_difference_t<_Iter>>(__d);
     return ranges::copy_n(std::move(__ifirst), __n, __ofirst);
   }
 else
   {
     auto __guard = __detail::_DestroyGuard(__ofirst);
     for (; __n > 0 && __ofirst != __olast;
   ++__ofirst, (void)++__ifirst, (void)--__n)
       ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
     __guard.release();
     return {std::move(__ifirst), __ofirst};
   }
      }
  };

  inline constexpr __uninitialized_copy_n_fn uninitialized_copy_n{};

  template<typename _Iter, typename _Out>
    using uninitialized_move_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_move_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
      __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _OSent>
      requires constructible_from<iter_value_t<_Out>,
      iter_rvalue_reference_t<_Iter>>

      uninitialized_move_result<_Iter, _Out>
      operator()(_Iter __ifirst, _ISent __ilast,
   _Out __ofirst, _OSent __olast) const
      {
 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
 if constexpr (sized_sentinel_for<_ISent, _Iter>
        && sized_sentinel_for<_OSent, _Out>
        && is_trivially_constructible_v<_OutType, iter_rvalue_reference_t<_Iter>>
        && is_trivially_default_constructible_v<_OutType>
        && is_trivially_assignable_v<_OutType&,
       iter_rvalue_reference_t<_Iter>>)
   {
     auto __d = __ilast - __ifirst;
     if (auto __d2 = __olast - __ofirst; __d2 < __d)
       __d = static_cast<iter_difference_t<_Iter>>(__d2);
     auto [__in, __out]
       = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
          __d, __ofirst);
     return {std::move(__in).base(), __out};
   }
 else
   {
     auto __guard = __detail::_DestroyGuard(__ofirst);
     for (; __ifirst != __ilast && __ofirst != __olast;
   ++__ofirst, (void)++__ifirst)
       ::new (__detail::__voidify(*__ofirst))
      _OutType(ranges::iter_move(__ifirst));
     __guard.release();
     return {std::move(__ifirst), __ofirst};
   }
      }

    template<input_range _IRange, __detail::__nothrow_forward_range _ORange>
      requires constructible_from<range_value_t<_ORange>,
        range_rvalue_reference_t<_IRange>>

      uninitialized_move_result<borrowed_iterator_t<_IRange>,
    borrowed_iterator_t<_ORange>>
      operator()(_IRange&& __inr, _ORange&& __outr) const
      {
 return (*this)(ranges::begin(__inr), ranges::end(__inr),
         ranges::begin(__outr), ranges::end(__outr));
      }
  };

  inline constexpr __uninitialized_move_fn uninitialized_move{};

  template<typename _Iter, typename _Out>
    using uninitialized_move_n_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_move_n_fn
  {
    template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _Sent>
 requires constructible_from<iter_value_t<_Out>,
        iter_rvalue_reference_t<_Iter>>

      uninitialized_move_n_result<_Iter, _Out>
      operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
   _Out __ofirst, _Sent __olast) const
      {
 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
 if constexpr (sized_sentinel_for<_Sent, _Out>
        && is_trivially_constructible_v<_OutType, iter_rvalue_reference_t<_Iter>>
        && is_trivially_default_constructible_v<_OutType>
        && is_trivially_assignable_v<_OutType&,
       iter_rvalue_reference_t<_Iter>>)
   {
     if (auto __d = __olast - __ofirst; __d < __n)
       __n = static_cast<iter_difference_t<_Iter>>(__d);
     auto [__in, __out]
       = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
          __n, __ofirst);
     return {std::move(__in).base(), __out};
   }
 else
   {
     auto __guard = __detail::_DestroyGuard(__ofirst);
     for (; __n > 0 && __ofirst != __olast;
   ++__ofirst, (void)++__ifirst, (void)--__n)
       ::new (__detail::__voidify(*__ofirst))
      _OutType(ranges::iter_move(__ifirst));
     __guard.release();
     return {std::move(__ifirst), __ofirst};
   }
      }
  };

  inline constexpr __uninitialized_move_n_fn uninitialized_move_n{};

  struct __uninitialized_fill_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter,
      __detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp>
      requires constructible_from<iter_value_t<_Iter>, const _Tp&>

      _Iter
      operator()(_Iter __first, _Sent __last, const _Tp& __x) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_constructible_v<_ValueType, const _Tp&>
        && is_trivially_assignable_v<_ValueType&, const _Tp&>)
   return ranges::fill(__first, __last, __x);
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __first != __last; ++__first)
       ::new (__detail::__voidify(*__first)) _ValueType(__x);
     __guard.release();
     return __first;
   }
      }

    template<__detail::__nothrow_forward_range _Range, typename _Tp>
      requires constructible_from<range_value_t<_Range>, const _Tp&>

      borrowed_iterator_t<_Range>
      operator()(_Range&& __r, const _Tp& __x) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r), __x);
      }
  };

  inline constexpr __uninitialized_fill_fn uninitialized_fill{};

  struct __uninitialized_fill_n_fn
  {
    template<__detail::__nothrow_forward_iterator _Iter, typename _Tp>
      requires constructible_from<iter_value_t<_Iter>, const _Tp&>

      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n,
   const _Tp& __x) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 if constexpr (is_trivially_constructible_v<_ValueType, const _Tp&>
        && is_trivially_assignable_v<_ValueType&, const _Tp&>)
   return ranges::fill_n(__first, __n, __x);
 else
   {
     auto __guard = __detail::_DestroyGuard(__first);
     for (; __n > 0; ++__first, (void)--__n)
       ::new (__detail::__voidify(*__first)) _ValueType(__x);
     __guard.release();
     return __first;
   }
      }
  };

  inline constexpr __uninitialized_fill_n_fn uninitialized_fill_n{};

  struct __construct_at_fn
  {
    template<typename _Tp, typename... _Args>
      requires requires {
 ::new (std::declval<void*>()) _Tp(std::declval<_Args>()...);
      }
      constexpr _Tp*
      operator()(_Tp* __location, _Args&&... __args) const
      noexcept(noexcept(std::construct_at(__location,
       std::forward<_Args>(__args)...)))
      {
 return std::construct_at(__location,
     std::forward<_Args>(__args)...);
      }
  };

  inline constexpr __construct_at_fn construct_at{};

  struct __destroy_at_fn
  {
    template<destructible _Tp>
      constexpr void
      operator()(_Tp* __location) const noexcept
      {
 if constexpr (is_array_v<_Tp>)
   ranges::destroy(ranges::begin(*__location), ranges::end(*__location));
 else
   __location->~_Tp();
      }
  };

  inline constexpr __destroy_at_fn destroy_at{};

  template<__detail::__nothrow_input_iterator _Iter,
    __detail::__nothrow_sentinel<_Iter> _Sent>
    requires destructible<iter_value_t<_Iter>>
    constexpr _Iter
    __destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept
    {
      if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
 return ranges::next(std::move(__first), __last);
      else
 {
   for (; __first != __last; ++__first)
     ranges::destroy_at(std::__addressof(*__first));
   return __first;
 }
    }

  template<__detail::__nothrow_input_range _Range>
    requires destructible<range_value_t<_Range>>
    constexpr borrowed_iterator_t<_Range>
    __destroy_fn::operator()(_Range&& __r) const noexcept
    {
      return (*this)(ranges::begin(__r), ranges::end(__r));
    }

  struct __destroy_n_fn
  {
    template<__detail::__nothrow_input_iterator _Iter>
      requires destructible<iter_value_t<_Iter>>
      constexpr _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept
      {
 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
   return ranges::next(std::move(__first), __n);
 else
   {
     for (; __n > 0; ++__first, (void)--__n)
       ranges::destroy_at(std::__addressof(*__first));
     return __first;
   }
      }
  };

  inline constexpr __destroy_n_fn destroy_n{};
}

}
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3
# 118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 119 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{
# 139 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }



}
# 174 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/glue_memory_defs.h" 1 3
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/glue_memory_defs.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/execution_defs.h" 1 3
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/execution_defs.h" 3
namespace __pstl
{
namespace execution
{
inline namespace v1
{


class sequenced_policy
{
};


class parallel_policy
{
};


class parallel_unsequenced_policy
{
};

class unsequenced_policy
{
};


inline constexpr sequenced_policy seq{};
inline constexpr parallel_policy par{};
inline constexpr parallel_unsequenced_policy par_unseq{};
inline constexpr unsequenced_policy unseq{};


template <class _Tp>
struct is_execution_policy : std::false_type
{
};

template <>
struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
{
};


template <class _Tp>
constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;


}
}

namespace __internal
{
template <class _ExecPolicy, class _Tp>

using __enable_if_execution_policy =
    typename std::enable_if<__pstl::execution::is_execution_policy<std::__remove_cvref_t<_ExecPolicy>>::value,
                            _Tp>::type;






template <class _IsVector>
struct __serial_tag;
template <class _IsVector>
struct __parallel_tag;

}

}
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/glue_memory_defs.h" 2 3

namespace std
{



template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);

template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);



template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);

template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);

}
# 175 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/memory" 2 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3


namespace boost
{

namespace detail
{



template<class D> class local_sp_deleter;

template<class D> D * get_local_deleter( D * ) noexcept
{
    return 0;
}

template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept;



template<class X> class __attribute__((__visibility__("default"))) sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;

    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );

    typedef sp_counted_impl_p<X> this_type;

public:

    explicit sp_counted_impl_p( X * px ): px_( px )
    {
    }

    void dispose() noexcept override
    {
        boost::checked_delete( px_ );
    }

    void * get_deleter( sp_typeinfo_ const & ) noexcept override
    {
        return 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ) noexcept override
    {
        return 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return 0;
    }
};

template<class P, class D> class __attribute__((__visibility__("default"))) sp_counted_impl_pd: public sp_counted_base
{
private:

    P ptr;
    D del;

    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );

    typedef sp_counted_impl_pd<P, D> this_type;

public:



    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( static_cast< D&& >( d ) )
    {
    }

    sp_counted_impl_pd( P p ): ptr( p ), del()
    {
    }

    void dispose() noexcept override
    {
        del( ptr );
    }

    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return &reinterpret_cast<char&>( del );
    }
};

template<class P, class D, class A> class __attribute__((__visibility__("default"))) sp_counted_impl_pda: public sp_counted_base
{
private:

    P p_;
    D d_;
    A a_;

    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );

    typedef sp_counted_impl_pda<P, D, A> this_type;

public:



    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( static_cast< D&& >( d ) ), a_( a )
    {
    }

    sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
    {
    }

    void dispose() noexcept override
    {
        d_( p_ );
    }

    void destroy() noexcept override
    {
        typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;

        A2 a2( a_ );

        this->~this_type();

        a2.deallocate( this, 1 );
    }

    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return &reinterpret_cast<char&>( d_ );
    }
};

}

}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 2 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


namespace boost
{

namespace movelib
{

template< class T, class D > class unique_ptr;

}

namespace detail
{

struct sp_nothrow_tag {};

template< class D > struct sp_inplace_tag
{
};

template< class T > class sp_reference_wrapper
{
public:

    explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
    {
    }

    template< class Y > void operator()( Y * p ) const
    {
        (*t_)( p );
    }

private:

    T * t_;
};

template< class D > struct sp_convert_reference
{
    typedef D type;
};

template< class D > struct sp_convert_reference< D& >
{
    typedef sp_reference_wrapper< D > type;
};

template<class T> std::size_t sp_hash_pointer( T* p ) noexcept
{
    std::uintptr_t v = reinterpret_cast<std::uintptr_t>( p );


    return static_cast<std::size_t>( v + ( v >> 3 ) );
}

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;

    friend class weak_count;

public:

    constexpr shared_count() noexcept: pi_(0)
    {
    }

    constexpr explicit shared_count( sp_counted_base * pi ) noexcept: pi_( pi )
    {
    }

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
    {


        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
# 145 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
    }

    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;
        }
# 172 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
    }

    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;
        }
# 199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
    }

    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;
        }
# 243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
    }

    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;
        }
# 287 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
    }





    template<class Y>
    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
    {
# 305 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
        r.release();
    }



    template<class Y, class D>
    explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
    {
        typedef typename sp_convert_reference<D>::type D2;

        D2 d2( static_cast<D&&>( r.get_deleter() ) );
        pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
# 327 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
        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 );
# 347 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/shared_count.hpp" 3
        r.release();
    }

    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();
    }

    shared_count(shared_count const & r) noexcept: pi_(r.pi_)
    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }

    shared_count(shared_count && r) noexcept: pi_(r.pi_)
    {
        r.pi_ = 0;
    }

    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag ) noexcept;

    shared_count & operator= (shared_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(shared_count & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const noexcept
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const noexcept
    {
        return use_count() == 1;
    }

    bool empty() const noexcept
    {
        return pi_ == 0;
    }

    bool operator==( shared_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator==( weak_count const & r ) const noexcept;

    bool operator<( shared_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    bool operator<( weak_count const & r ) const noexcept;

    void * get_deleter( sp_typeinfo_ const & ti ) const noexcept
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) const noexcept
    {
        return pi_? pi_->get_local_deleter( ti ): 0;
    }

    void * get_untyped_deleter() const noexcept
    {
        return pi_? pi_->get_untyped_deleter(): 0;
    }

    std::size_t hash_value() const noexcept
    {
        return sp_hash_pointer( pi_ );
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;

    friend class shared_count;

public:

    constexpr weak_count() noexcept: pi_(0)
    {
    }

    weak_count(shared_count const & r) noexcept: pi_(r.pi_)
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

    weak_count(weak_count const & r) noexcept: pi_(r.pi_)
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }



    weak_count(weak_count && r) noexcept: pi_(r.pi_)
    {
        r.pi_ = 0;
    }

    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();
    }

    weak_count & operator= (shared_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    weak_count & operator= (weak_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(weak_count & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const noexcept
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool empty() const noexcept
    {
        return pi_ == 0;
    }

    bool operator==( weak_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator==( shared_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator<( weak_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    bool operator<( shared_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    std::size_t hash_value() const noexcept
    {
        return sp_hash_pointer( pi_ );
    }
};

inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
{
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) noexcept: pi_( r.pi_ )
{
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
}

inline bool shared_count::operator==( weak_count const & r ) const noexcept
{
    return pi_ == r.pi_;
}

inline bool shared_count::operator<( weak_count const & r ) const noexcept
{
    return std::less<sp_counted_base *>()( pi_, r.pi_ );
}

}

}


#pragma GCC diagnostic pop
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_convertible.hpp" 3
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 >
{
};

}

}
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/sp_noexcept.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock.hpp" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/yield_k.hpp" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/yield_k.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/yield_primitives.hpp" 1 3







# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_pause.hpp" 1 3
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_pause.hpp" 3
namespace boost
{
namespace core
{

inline __attribute__ ((__always_inline__)) void sp_thread_pause() noexcept
{
    __builtin_ia32_pause();
}

}
}
# 9 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/yield_primitives.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_yield.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_yield.hpp" 3
namespace boost
{
namespace core
{

inline void sp_thread_yield() noexcept
{
    sched_yield();
}

}
}
# 10 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/yield_primitives.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_sleep.hpp" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/detail/sp_thread_sleep.hpp" 3
namespace boost
{
namespace core
{

inline void sp_thread_sleep() noexcept
{


    int oldst;
    pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &oldst );




    struct timespec rqtp = { 0, 0 };




    rqtp.tv_sec = 0;
    rqtp.tv_nsec = 1000;

    nanosleep( &rqtp, 0 );



    pthread_setcancelstate( oldst, &oldst );



}

}
}
# 11 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/yield_primitives.hpp" 2 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/yield_k.hpp" 2 3

namespace boost
{

namespace detail
{

inline void yield( unsigned k )
{



    if( k & 1 )
    {
        boost::core::sp_thread_sleep();
    }
    else
    {
        boost::core::sp_thread_pause();
    }
}

}

}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 2 3








namespace boost
{

namespace detail
{

class spinlock
{
public:






    union
    {
        unsigned char v_;
        bool align_;
    };

public:

    bool try_lock()
    {
        return __atomic_test_and_set( &v_, 2 ) == 0;
    }

    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }

    void unlock()
    {
        __atomic_clear( &v_, 3 );
    }

public:

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

}
}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock.hpp" 2 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3


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}}
};

}
}
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 1 3
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/algorithmfwd.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/algorithmfwd.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 200 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/algorithmfwd.h" 3
  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    all_of(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    any_of(_IIter, _IIter, _Predicate);


  template<typename _FIter, typename _Tp >
    constexpr
    bool
    binary_search(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp ,
    typename _Compare>
    constexpr
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);


  template<typename _Tp>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);


  template<typename _IIter, typename _OIter>
    constexpr
    _OIter
    copy(_IIter, _IIter, _OIter);

  template<typename _BIter1, typename _BIter2>
    constexpr
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);


  template<typename _IIter, typename _OIter, typename _Predicate>
    constexpr
    _OIter
    copy_if(_IIter, _IIter, _OIter, _Predicate);

  template<typename _IIter, typename _Size, typename _OIter>
    constexpr
    _OIter
    copy_n(_IIter, _Size, _OIter);





  template<typename _FIter, typename _Tp >
    constexpr
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp ,
    typename _Compare>
    constexpr
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _FIter, typename _Tp >
    constexpr
    void
    fill(_FIter, _FIter, const _Tp&);

  template<typename _OIter, typename _Size,
    typename _Tp >
    constexpr
    _OIter
    fill_n(_OIter, _Size, const _Tp&);



  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);





  template<typename _IIter, typename _Predicate>
    constexpr
    _IIter
    find_if_not(_IIter, _IIter, _Predicate);






  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    constexpr
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _BIter>

    void
    inplace_merge(_BIter, _BIter, _BIter);

  template<typename _BIter, typename _Compare>

    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);


  template<typename _RAIter>
    constexpr
    bool
    is_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    bool
    is_heap(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    constexpr
    _RAIter
    is_heap_until(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    _RAIter
    is_heap_until(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    is_partitioned(_IIter, _IIter, _Predicate);

  template<typename _FIter1, typename _FIter2>
    constexpr
    bool
    is_permutation(_FIter1, _FIter1, _FIter2);

  template<typename _FIter1, typename _FIter2,
    typename _BinaryPredicate>
    constexpr
    bool
    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

  template<typename _FIter>
    constexpr
    bool
    is_sorted(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    bool
    is_sorted(_FIter, _FIter, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    is_sorted_until(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    is_sorted_until(_FIter, _FIter, _Compare);


  template<typename _FIter1, typename _FIter2>
    constexpr
    void
    iter_swap(_FIter1, _FIter2);

  template<typename _FIter, typename _Tp >
    constexpr
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp ,
    typename _Compare>
    constexpr
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _RAIter>
    constexpr
    void
    make_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    make_heap(_RAIter, _RAIter, _Compare);

  template<typename _Tp>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&, _Compare);

  template<typename _FIter>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    min(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    min(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    max(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    max(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>, _Compare);




  template<typename _BIter>
    constexpr
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    constexpr
    bool
    next_permutation(_BIter, _BIter, _Compare);


  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    none_of(_IIter, _IIter, _Predicate);





  template<typename _IIter, typename _RAIter>
    constexpr
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  template<typename _IIter, typename _RAIter, typename _Compare>
    constexpr
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);




  template<typename _IIter, typename _OIter1,
    typename _OIter2, typename _Predicate>
    constexpr
    pair<_OIter1, _OIter2>
    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

  template<typename _FIter, typename _Predicate>
    constexpr
    _FIter
    partition_point(_FIter, _FIter, _Predicate);


  template<typename _RAIter>
    constexpr
    void
    pop_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    pop_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter>
    constexpr
    bool
    prev_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    constexpr
    bool
    prev_permutation(_BIter, _BIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    push_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    push_heap(_RAIter, _RAIter, _Compare);



  template<typename _FIter, typename _Tp >
    constexpr
    _FIter
    remove(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Predicate>
    constexpr
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

  template<typename _IIter, typename _OIter,
    typename _Tp >
    constexpr
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  template<typename _IIter, typename _OIter, typename _Predicate>
    constexpr
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);



  template<typename _IIter, typename _OIter, typename _Tp>
    constexpr
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  template<typename _Iter, typename _OIter, typename _Predicate,
    typename _Tp >
    constexpr
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);



  template<typename _BIter>
    constexpr
    void
    reverse(_BIter, _BIter);

  template<typename _BIter, typename _OIter>
    constexpr
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

inline namespace _V2 {

  template<typename _FIter>
    constexpr
    _FIter
    rotate(_FIter, _FIter, _FIter);

}

  template<typename _FIter, typename _OIter>
    constexpr
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 635 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/algorithmfwd.h" 3
  template<typename _RAIter, typename _UGenerator>
    void
    shuffle(_RAIter, _RAIter, _UGenerator&&);


  template<typename _RAIter>
    constexpr
    void
    sort_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    sort_heap(_RAIter, _RAIter, _Compare);


  template<typename _BIter, typename _Predicate>

    _BIter
    stable_partition(_BIter, _BIter, _Predicate);
# 671 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/algorithmfwd.h" 3
  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);



  template<typename _FIter>
    constexpr
    _FIter
    unique(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    constexpr
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);



  template<typename _FIter, typename _Tp >
    constexpr
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp ,
    typename _Compare>
    constexpr
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);



  template<typename _FIter>
    constexpr
    _FIter
    adjacent_find(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    constexpr
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

  template<typename _IIter, typename _Tp >
    constexpr
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

  template<typename _IIter, typename _Predicate>
    constexpr
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    equal(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    constexpr
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _IIter, typename _Tp >
    constexpr
    _IIter
    find(_IIter, _IIter, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _IIter, typename _Predicate>
    constexpr
    _IIter
    find_if(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Funct>
    constexpr
    _Funct
    for_each(_IIter, _IIter, _Funct);

  template<typename _FIter, typename _Generator>
    constexpr
    void
    generate(_FIter, _FIter, _Generator);

  template<typename _OIter, typename _Size, typename _Generator>
    constexpr
    _OIter
    generate_n(_OIter, _Size, _Generator);

  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    constexpr
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    max_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    min_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2>
    constexpr
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    constexpr
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _RAIter>
    constexpr
    void
    nth_element(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    constexpr
    _BIter
    partition(_BIter, _BIter, _Predicate);


  template<typename _RAIter>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RAIter, _RAIter);

  template<typename _RAIter, typename _Generator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RAIter, _RAIter,

     _Generator&&);





  template<typename _FIter, typename _Tp >
    constexpr
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

  template<typename _FIter, typename _Predicate,
    typename _Tp >
    constexpr
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _FIter, typename _Size,
    typename _Tp >
    constexpr
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

  template<typename _FIter, typename _Size,
    typename _Tp ,
    typename _BinaryPredicate>
    constexpr
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
        _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    sort(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>

    void
    stable_sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>

    void
    stable_sort(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _OIter, typename _UnaryOperation>
    constexpr
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _BinaryOperation>
    constexpr
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  template<typename _IIter, typename _OIter>
    constexpr
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
    constexpr
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);



}

#pragma GCC diagnostic pop
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    constexpr
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      _Compare& __comp)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first + __parent, __first + __child))
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }



  template<typename _RandomAccessIterator, typename _Distance>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    {
      __gnu_cxx::__ops::_Iter_less_iter __comp;
      return std::__is_heap_until(__first, __n, __comp) == __n;
    }

  template<typename _RandomAccessIterator, typename _Compare,
    typename _Distance>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
    {
      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return std::__is_heap_until(__first, __n, __cmp) == __n;
    }

  template<typename _RandomAccessIterator>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      return std::__is_heap(__first, std::move(__comp),
       std::distance(__first, __last));
    }




  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
    typename _Compare>
    constexpr
    void
    __push_heap(_RandomAccessIterator __first,
  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
  _Compare& __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
 {
   *(__first + __holeIndex) = std::move(*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = std::move(__value);
    }
# 159 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;





                                                     ;
                                                     ;
                                                  ;

      __gnu_cxx::__ops::_Iter_less_val __comp;
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __comp);
    }
# 195 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;




                                                     ;
                                                                  ;
                                                               ;

      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
    constexpr
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (__comp(__first + __secondChild,
       __first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));

   __holeIndex = __secondChild - 1;
 }
      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      std::__push_heap(__first, __holeIndex, __topIndex,
         std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = std::move(*__result);
      *__result = std::move(*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    std::move(__value), __comp);
    }
# 280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





      do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false);
                                                     ;
                                                     ;
                                              ;

      if (__last - __first > 1)
 {
   --__last;
   __gnu_cxx::__ops::_Iter_less_iter __comp;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 314 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {



                                                     ;
                                                                  ;
      do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } 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>
    constexpr
    void
    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = std::move(*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, std::move(__value),
        __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 372 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__make_heap(__first, __last, __comp);
    }
# 399 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {



                                                     ;
                                                                  ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      std::__make_heap(__first, __last, __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;
                                              ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__sort_heap(__first, __last, __comp);
    }
# 465 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {



                                                     ;
                                                                  ;
                                                           ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      std::__sort_heap(__first, __last, __cmp);
    }
# 494 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    [[__nodiscard__]] constexpr
    inline _RandomAccessIterator
    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      return __first +
 std::__is_heap_until(__first, std::distance(__first, __last), __comp);
    }
# 523 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _RandomAccessIterator
    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {



                                                     ;
                                                                  ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return __first
 + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
    }
# 548 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    [[__nodiscard__]] constexpr
    inline bool
    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::is_heap_until(__first, __last) == __last; }
# 562 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _Compare __comp)
    {



                                                     ;
                                                                  ;

      const auto __dist = std::distance(__first, __last);
      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return std::__is_heap_until(__first, __dist, __cmp) == __dist;
    }



}
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 3
  template<typename _Gen>
    concept uniform_random_bit_generator
      = invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>>
      && requires
      {
 { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
 { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
 requires bool_constant<(_Gen::min() < _Gen::max())>::value;
      };



  namespace __detail
  {



    template<typename _Tp>
      constexpr bool
      _Power_of_2(_Tp __x)
      {
 return ((__x - 1) & __x) == 0;
      }
  }
# 87 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 3
  template<typename _IntType = int>
    class uniform_int_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "template argument must be an integral type");

    public:

      typedef _IntType result_type;

      struct param_type
      {
 typedef uniform_int_distribution<_IntType> distribution_type;

 param_type() : param_type(0) { }

 explicit
 param_type(_IntType __a,
     _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max)
 : _M_a(__a), _M_b(__b)
 {
   do { if (std::__is_constant_evaluated() && !bool(_M_a <= _M_b)) std::__glibcxx_assert_fail(); } while (false);
 }

 result_type
 a() const
 { return _M_a; }

 result_type
 b() const
 { return _M_b; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _IntType _M_a;
 _IntType _M_b;
      };

    public:



      uniform_int_distribution() : uniform_int_distribution(0) { }




      explicit
      uniform_int_distribution(_IntType __a,
          _IntType __b
     = __gnu_cxx::__int_traits<_IntType>::__max)
      : _M_param(__a, __b)
      { }

      explicit
      uniform_int_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }

      result_type
      a() const
      { return _M_param.a(); }

      result_type
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return this->a(); }




      result_type
      max() const
      { return this->b(); }




      template<typename _UniformRandomBitGenerator>
 result_type
 operator()(_UniformRandomBitGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomBitGenerator>
 result_type
 operator()(_UniformRandomBitGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomBitGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomBitGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomBitGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomBitGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const uniform_int_distribution& __d1,
   const uniform_int_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomBitGenerator& __urng,
   const param_type& __p);

      param_type _M_param;




      template<typename _Wp, typename _Urbg, typename _Up>
 static _Up
 _S_nd(_Urbg& __g, _Up __range)
 {
   using _Up_traits = __gnu_cxx::__int_traits<_Up>;
   using _Wp_traits = __gnu_cxx::__int_traits<_Wp>;
   static_assert(!_Up_traits::__is_signed, "U must be unsigned");
   static_assert(!_Wp_traits::__is_signed, "W must be unsigned");
   static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits),
   "W must be twice as wide as U");




   _Wp __product = _Wp(__g()) * _Wp(__range);
   _Up __low = _Up(__product);
   if (__low < __range)
     {
       _Up __threshold = -__range % __range;
       while (__low < __threshold)
  {
    __product = _Wp(__g()) * _Wp(__range);
    __low = _Up(__product);
  }
     }
   return __product >> _Up_traits::__digits;
 }
    };

  template<typename _IntType>
    template<typename _UniformRandomBitGenerator>
      typename uniform_int_distribution<_IntType>::result_type
      uniform_int_distribution<_IntType>::
      operator()(_UniformRandomBitGenerator& __urng,
   const param_type& __param)
      {
 typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
 typedef typename make_unsigned<result_type>::type __utype;
 typedef typename common_type<_Gresult_type, __utype>::type __uctype;

 constexpr __uctype __urngmin = _UniformRandomBitGenerator::min();
 constexpr __uctype __urngmax = _UniformRandomBitGenerator::max();
 static_assert( __urngmin < __urngmax,
     "Uniform random bit generator must define min() < max()");
 constexpr __uctype __urngrange = __urngmax - __urngmin;

 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;
 if (__urngrange > __urange)
   {


     const __uctype __uerange = __urange + 1;



     if constexpr (__urngrange == 18446744073709551615UL)
       {


  long unsigned int __u64erange = __uerange;
  __ret = __extension__ _S_nd<unsigned __int128>(__urng,
              __u64erange);
       }
     else

     if constexpr (__urngrange == 4294967295U)
       {


  unsigned int __u32erange = __uerange;
  __ret = _S_nd<long unsigned int>(__urng, __u32erange);
       }
     else

       {

  const __uctype __scaling = __urngrange / __uerange;
  const __uctype __past = __uerange * __scaling;
  do
    __ret = __uctype(__urng()) - __urngmin;
  while (__ret >= __past);
  __ret /= __scaling;
       }
   }
 else if (__urngrange < __urange)
   {
# 359 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     do
       {
  const __uctype __uerngrange = __urngrange + 1;
  __tmp = (__uerngrange * operator()
    (__urng, param_type(0, __urange / __uerngrange)));
  __ret = __tmp + (__uctype(__urng()) - __urngmin);
       }
     while (__ret > __urange || __ret < __tmp);
   }
 else
   __ret = __uctype(__urng()) - __urngmin;

 return __ret + __param.a();
      }


  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomBitGenerator>
      void
      uniform_int_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomBitGenerator& __urng,
        const param_type& __param)
      {

 typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
 typedef typename make_unsigned<result_type>::type __utype;
 typedef typename common_type<_Gresult_type, __utype>::type __uctype;

 static_assert( __urng.min() < __urng.max(),
     "Uniform random bit generator must define min() < max()");

 constexpr __uctype __urngmin = __urng.min();
 constexpr __uctype __urngmax = __urng.max();
 constexpr __uctype __urngrange = __urngmax - __urngmin;
 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;

 if (__urngrange > __urange)
   {
     if (__detail::_Power_of_2(__urngrange + 1)
  && __detail::_Power_of_2(__urange + 1))
       {
  while (__f != __t)
    {
      __ret = __uctype(__urng()) - __urngmin;
      *__f++ = (__ret & __urange) + __param.a();
    }
       }
     else
       {

  const __uctype __uerange = __urange + 1;
  const __uctype __scaling = __urngrange / __uerange;
  const __uctype __past = __uerange * __scaling;
  while (__f != __t)
    {
      do
        __ret = __uctype(__urng()) - __urngmin;
      while (__ret >= __past);
      *__f++ = __ret / __scaling + __param.a();
    }
       }
   }
 else if (__urngrange < __urange)
   {
# 444 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     while (__f != __t)
       {
  do
    {
      constexpr __uctype __uerngrange = __urngrange + 1;
      __tmp = (__uerngrange * operator()
        (__urng, param_type(0, __urange / __uerngrange)));
      __ret = __tmp + (__uctype(__urng()) - __urngmin);
    }
  while (__ret > __urange || __ret < __tmp);
  *__f++ = __ret;
       }
   }
 else
   while (__f != __t)
     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
      }




}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 2 3
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"



namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Iterator, typename _Compare>
    constexpr
    void
    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
      _Iterator __c, _Compare __comp)
    {
      if (__comp(__a, __b))
 {
   if (__comp(__b, __c))
     std::iter_swap(__result, __b);
   else if (__comp(__a, __c))
     std::iter_swap(__result, __c);
   else
     std::iter_swap(__result, __a);
 }
      else if (__comp(__a, __c))
 std::iter_swap(__result, __a);
      else if (__comp(__b, __c))
 std::iter_swap(__result, __c);
      else
 std::iter_swap(__result, __b);
    }


  template<typename _InputIterator, typename _Predicate>
    constexpr
    inline _InputIterator
    __find_if_not(_InputIterator __first, _InputIterator __last,
    _Predicate __pred)
    {
      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__negate(__pred));
    }




  template<typename _InputIterator, typename _Predicate, typename _Distance>
    constexpr
    _InputIterator
    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
    {
      for (; __len; --__len, (void) ++__first)
 if (!__pred(__first))
   break;
      return __first;
    }
# 150 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _ForwardIterator
    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::forward_iterator_tag)
    {
      __first = std::__find_if(__first, __last, __unary_pred);
      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && __unary_pred(__i))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = std::__find_if(++__i, __last, __unary_pred);
 }
      return __last;
    }





  template<typename _RandomAccessIter, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _RandomAccessIter
    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::random_access_iterator_tag)
    {
      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      _DistanceType __remainder = __count;

      while (__remainder <= __tailSize)
 {
   __first += __remainder;
   __tailSize -= __remainder;


   _RandomAccessIter __backTrack = __first;
   while (__unary_pred(--__backTrack))
     {
       if (--__remainder == 0)
  return (__first - __count);
     }
   __remainder = __count + 1 - (__first - __backTrack);
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count,
        _UnaryPredicate __unary_pred)
    {
      if (__count <= 0)
 return __first;

      if (__count == 1)
 return std::__find_if(__first, __last, __unary_pred);

      return std::__search_n_aux(__first, __last, __count, __unary_pred,
     std::__iterator_category(__first));
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;

      _ForwardIterator1 __result = __last1;
      while (1)
 {
   _ForwardIterator1 __new_result
     = std::__search(__first1, __last1, __first2, __last2, __comp);
   if (__new_result == __last1)
     return __result;
   else
     {
       __result = __new_result;
       __first1 = __new_result;
       ++__first1;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
    constexpr
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {






      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
           _RevIterator2(__last2), __rlast2,
           __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 324 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 373 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __comp)
    {






                                                       ;
                                                       ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 409 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if_not(__first, __last, __pred); }
# 427 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if(__first, __last, __pred); }
# 446 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return !std::none_of(__first, __last, __pred); }
# 462 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _InputIterator
    find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
    {




                                                     ;
      return std::__find_if_not(__first, __last,
    __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 487 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_partitioned(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {
      __first = std::find_if_not(__first, __last, __pred);
      if (__first == __last)
 return true;
      ++__first;
      return std::none_of(__first, __last, __pred);
    }
# 509 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    _ForwardIterator
    partition_point(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred)
    {






                                                     ;

      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__pred(*__middle))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }


  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    _OutputIterator
    __remove_copy_if(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _Predicate __pred)
    {
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 576 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    constexpr
    inline _OutputIterator
    remove_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, const _Tp& __value)
    {






                                                     ;

      return std::__remove_copy_if(__first, __last, __result,
 __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 609 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    inline _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {






                                                     ;

      return std::__remove_copy_if(__first, __last, __result,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 644 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    _OutputIterator
    copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {






                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 681 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
    {





      const auto __n2 = std::__size_to_integer(__n);
      if (__n2 <= 0)
 return __result;

                                                     ;
                                                      ;

      auto __res = std::__copy_n_a(std::__niter_base(__first), __n2,
       std::__niter_base(__result), true);
      return std::__niter_wrap(__result, std::move(__res));
    }
# 718 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator1,
    typename _OutputIterator2, typename _Predicate>
    constexpr
    pair<_OutputIterator1, _OutputIterator2>
    partition_copy(_InputIterator __first, _InputIterator __last,
     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
     _Predicate __pred)
    {
# 734 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__out_true = *__first;
     ++__out_true;
   }
 else
   {
     *__out_false = *__first;
     ++__out_false;
   }

      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
    }
# 769 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {





                                                     ;

      return std::__remove_if(__first, __last,
  __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__remove_if(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while (++__next != __last)
 {
   if (__binary_pred(__first, __next))
     return __first;
   __first = __next;
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __unique(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {

      __first = std::__adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!__binary_pred(__dest, __first))
   *++__dest = std::move(*__first);
      return ++__dest;
    }
# 872 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last)
    {





                                                     ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 903 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {






                                                     ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }







  template<typename _ForwardIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    forward_iterator_tag, output_iterator_tag)
    {





      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!__binary_pred(__first, __next))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, output_iterator_tag)
    {





      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
 __rebound_pred
 = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
      *__result = __value;
      while (++__first != __last)
 if (!__rebound_pred(__first, __value))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, forward_iterator_tag)
    {




      *__result = *__first;
      while (++__first != __last)
 if (!__binary_pred(__result, __first))
   *++__result = *__first;
      return ++__result;
    }






  template<typename _BidirectionalIterator>
    constexpr
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   {
     std::iter_swap(__first, __last);
     ++__first;
   }
    }






  template<typename _RandomAccessIterator>
    constexpr
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
       random_access_iterator_tag)
    {
      if (__first == __last)
 return;
      --__last;
      while (__first < __last)
 {
   std::iter_swap(__first, __last);
   ++__first;
   --__last;
 }
    }
# 1064 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {



                                                     ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1092 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
    constexpr
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
   _OutputIterator __result)
    {





                                                     ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }





  template<typename _EuclideanRingElement>
    constexpr
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }

inline namespace _V2 {


  template<typename _ForwardIterator>
    constexpr
    _ForwardIterator
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
      forward_iterator_tag)
    {
      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      _ForwardIterator __first2 = __middle;
      do
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      _ForwardIterator __ret = __first;

      __first2 = __middle;

      while (__first2 != __last)
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
      return __ret;
    }


  template<typename _BidirectionalIterator>
    constexpr
    _BidirectionalIterator
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {




      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 {
   std::iter_swap(__first, --__last);
   ++__first;
 }

      if (__first == __middle)
 {
   std::__reverse(__middle, __last, bidirectional_iterator_tag());
   return __last;
 }
      else
 {
   std::__reverse(__first, __middle, bidirectional_iterator_tag());
   return __first;
 }
    }


  template<typename _RandomAccessIterator>
    constexpr
    _RandomAccessIterator
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {




      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


      typedef typename make_unsigned<_Distance>::type _UDistance;




      _Distance __n = __last - __first;
      _Distance __k = __middle - __first;

      if (__k == __n - __k)
 {
   std::swap_ranges(__first, __middle, __middle);
   return __middle;
 }

      _RandomAccessIterator __p = __first;
      _RandomAccessIterator __ret = __first + (__last - __middle);

      for (;;)
 {
   if (__k < __n - __k)
     {
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*__p);
    std::move(__p + 1, __p + __n, __p);
    *(__p + __n - 1) = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    std::iter_swap(__p, __q);
    ++__p;
    ++__q;
  }
       __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k);
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
       __k = __n - __k;
     }
   else
     {
       __k = __n - __k;
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*(__p + __n - 1));
    std::move_backward(__p, __p + __n - 1, __p + __n);
    *__p = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __n;
       __p = __q - __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    --__p;
    --__q;
    std::iter_swap(__p, __q);
  }
       __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k);
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
     }
 }
    }
# 1329 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    constexpr
    inline _ForwardIterator
    rotate(_ForwardIterator __first, _ForwardIterator __middle,
    _ForwardIterator __last)
    {



                                                       ;
                                                      ;

      return std::__rotate(__first, __middle, __last,
      std::__iterator_category(__first));
    }

}
# 1367 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last, _OutputIterator __result)
    {




                                                       ;
                                                      ;

      return std::copy(__first, __middle,
         std::copy(__middle, __last, __result));
    }


  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred, forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     std::iter_swap(__first, __next);
     ++__first;
   }

      return __first;
    }


  template<typename _BidirectionalIterator, typename _Predicate>
    constexpr
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
  _Predicate __pred, bidirectional_iterator_tag)
    {
      while (true)
 {
   while (true)
     if (__first == __last)
       return __first;
     else if (__pred(*__first))
       ++__first;
     else
       break;
   --__last;
   while (true)
     if (__first == __last)
       return __first;
     else if (!bool(__pred(*__last)))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }
# 1448 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;

      const _DistanceType __len = std::distance(__first, __last);
# 1540 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
      _Temporary_buffer<_ForwardIterator, _ValueType>
 __buf(__first, __len);
      return
 std::__stable_partition_adaptive(__first, __last, __pred,
      __len,
      __buf.begin(),
      _DistanceType(__buf.size()));
    }
# 1566 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>

    inline _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__stable_partition(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }





  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last, _Compare __comp)
    {
      std::__make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(__i, __first))
   std::__pop_heap(__first, __middle, __i, __comp);
    }



  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
    constexpr
    _RandomAccessIterator
    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
   _RandomAccessIterator __result_first,
   _RandomAccessIterator __result_last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
      typedef typename _RItTraits::difference_type _DistanceType;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while (__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }

      std::__make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last)
 {
   if (__comp(__first, __result_first))
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first), __comp);
   ++__first;
 }
      std::__sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }
# 1660 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator>
    constexpr
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last)
    {
# 1681 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                     ;
                                                     ;
                                                                   ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
          __gnu_cxx::__ops::__iter_less_iter());
    }
# 1710 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
    constexpr
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last,
        _Compare __comp)
    {
# 1736 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                     ;
                                                                  ;
                                                                   ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __unguarded_linear_insert(_RandomAccessIterator __last,
         _Compare __comp)
    {
      typename iterator_traits<_RandomAccessIterator>::value_type
 __val = std::move(*__last);
      _RandomAccessIterator __next = __last;
      --__next;
      while (__comp(__val, __next))
 {
   *__last = std::move(*__next);
   __last = __next;
   --__next;
 }
      *__last = std::move(__val);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last, _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   if (__comp(__i, __first))
     {
       typename iterator_traits<_RandomAccessIterator>::value_type
  __val = std::move(*__i);
       std::move_backward(__first, __i, __i + 1);
       *__first = std::move(__val);
     }
   else
     std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
    {
      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }





  enum { _S_threshold = 16 };


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _RandomAccessIterator __pivot, _Compare __comp)
    {
      while (true)
 {
   while (__comp(__first, __pivot))
     ++__first;
   --__last;
   while (__comp(__pivot, __last))
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
    _RandomAccessIterator __last, _Compare __comp)
    {
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
      __comp);
      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __partial_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __middle,
     _RandomAccessIterator __last,
     _Compare __comp)
    {
      std::__heap_select(__first, __middle, __last, __comp);
      std::__sort_heap(__first, __middle, __comp);
    }


  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    constexpr
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit, _Compare __comp)
    {
      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::__partial_sort(__first, __last, __last, __comp);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }



  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2,
    __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }

  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    constexpr
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit,
    _Compare __comp)
    {
      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last, __comp);

       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 1961 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {





                    ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp));
    }

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    constexpr
    _ForwardIterator
    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, __middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2017 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




                                                                  ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2048 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {





                    ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Tp,
    typename _CompareItTp, typename _CompareTpIt>
    constexpr
    pair<_ForwardIterator, _ForwardIterator>
    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val,
    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp_it_val(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__comp_val_it(__val, __middle))
     __len = __half;
   else
     {
       _ForwardIterator __left
  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
       std::advance(__first, __len);
       _ForwardIterator __right
  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 2121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {






                                                                  ;
                                                                  ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val(),
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2158 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {







                    ;

                    ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp),
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }
# 2192 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val)
    {




                                                                  ;
                                                                  ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_less_val());
      return __i != __last && !(__val < *__i);
    }
# 2226 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {





                    ;

                    ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_comp_val(__comp));
      return __i != __last && !bool(__comp(__val, *__i));
    }




  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    void
    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      if (__first1 != __last1)
 std::move(__first1, __last1, __result);
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    void
    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 {
   std::move_backward(__first2, __last2, __result);
   return;
 }
      else if (__first2 == __last2)
 return;

      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(__last2, __last1))
     {
       *--__result = std::move(*__last1);
       if (__first1 == __last1)
  {
    std::move_backward(__first2, ++__last2, __result);
    return;
  }
       --__last1;
     }
   else
     {
       *--__result = std::move(*__last2);
       if (__first2 == __last2)
  return;
       --__last2;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _Distance>
    _BidirectionalIterator1
    __rotate_adaptive(_BidirectionalIterator1 __first,
        _BidirectionalIterator1 __middle,
        _BidirectionalIterator1 __last,
        _Distance __len1, _Distance __len2,
        _BidirectionalIterator2 __buffer,
        _Distance __buffer_size)
    {
      _BidirectionalIterator2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size)
 {
   if (__len2)
     {
       __buffer_end = std::move(__middle, __last, __buffer);
       std::move_backward(__first, __middle, __last);
       return std::move(__buffer, __buffer_end, __first);
     }
   else
     return __first;
 }
      else if (__len1 <= __buffer_size)
 {
   if (__len1)
     {
       __buffer_end = std::move(__first, __middle, __buffer);
       std::move(__middle, __last, __first);
       return std::move_backward(__buffer, __buffer_end, __last);
     }
   else
     return __last;
 }
      else
 return std::rotate(__first, __middle, __last);
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive(_BidirectionalIterator __first,
       _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Compare __comp)
    {
      if (__len1 <= __len2)
 {
   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
         __first, __comp);
 }
      else
 {
   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
           __buffer_end, __last, __comp);
 }
    }

  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive_resize(_BidirectionalIterator __first,
       _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size,
       _Compare __comp)
    {
      if (__len1 <= __buffer_size || __len2 <= __buffer_size)
 std::__merge_adaptive(__first, __middle, __last,
         __len1, __len2, __buffer, __comp);
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut
  = std::__lower_bound(__middle, __last, *__first_cut,
         __gnu_cxx::__ops::__iter_comp_val(__comp));
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut
  = std::__upper_bound(__first, __middle, *__second_cut,
         __gnu_cxx::__ops::__val_comp_iter(__comp));
       __len11 = std::distance(__first, __first_cut);
     }

   _BidirectionalIterator __new_middle
     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
         _Distance(__len1 - __len11), __len22,
         __buffer, __buffer_size);
   std::__merge_adaptive_resize(__first, __first_cut, __new_middle,
           __len11, __len22,
           __buffer, __buffer_size, __comp);
   std::__merge_adaptive_resize(__new_middle, __second_cut, __last,
           _Distance(__len1 - __len11),
           _Distance(__len2 - __len22),
           __buffer, __buffer_size, __comp);
 }
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>

    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;

      if (__len1 + __len2 == 2)
 {
   if (__comp(__middle, __first))
     std::iter_swap(__first, __middle);
   return;
 }

      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut
     = std::__lower_bound(__middle, __last, *__first_cut,
     __gnu_cxx::__ops::__iter_comp_val(__comp));
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut
     = std::__upper_bound(__first, __middle, *__second_cut,
     __gnu_cxx::__ops::__val_comp_iter(__comp));
   __len11 = std::distance(__first, __first_cut);
 }

      _BidirectionalIterator __new_middle
 = std::rotate(__first_cut, __middle, __second_cut);
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }

  template<typename _BidirectionalIterator, typename _Compare>

    void
    __inplace_merge(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
   _DistanceType;

      if (__first == __middle || __middle == __last)
 return;

      const _DistanceType __len1 = std::distance(__first, __middle);
      const _DistanceType __len2 = std::distance(__middle, __last);
# 2510 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;


      _TmpBuf __buf(__first, std::min(__len1, __len2));

      if (__builtin_expect(__buf.size() == __buf.requested_size(), true))
 std::__merge_adaptive
   (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp);
      else if (__builtin_expect(__buf.begin() == 0, false))
 std::__merge_without_buffer
   (__first, __middle, __last, __len1, __len2, __comp);
      else
 std::__merge_adaptive_resize
   (__first, __middle, __last, __len1, __len2, __buf.begin(),
    _DistanceType(__buf.size()), __comp);




    }
# 2549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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());
    }
# 2591 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>

    inline void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
    {






                                                               ;
                                                              ;
                                                                  ;

      std::__inplace_merge(__first, __middle, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _InputIterator, typename _OutputIterator,
    typename _Compare>
    _OutputIterator
    __move_merge(_InputIterator __first1, _InputIterator __last1,
   _InputIterator __first2, _InputIterator __last2,
   _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      return std::move(__first2, __last2, std::move(__first1, __last1, __result));


    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result, _Distance __step_size,
        _Compare __comp)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::__move_merge(__first, __first + __step_size,
           __first + __step_size,
           __first + __two_step,
           __result, __comp);
   __first += __two_step;
 }
      __step_size = std::min(_Distance(__last - __first), __step_size);

      std::__move_merge(__first, __first + __step_size,
   __first + __step_size, __last, __result, __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    constexpr
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
        _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      _Pointer __buffer, _Compare __comp)
    {
      std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
      std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);

      std::__merge_adaptive(__first, __middle, __last,
       __middle - __first, __last - __middle,
       __buffer, __comp);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive_resize(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Pointer __buffer, _Distance __buffer_size,
      _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive_resize(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive_resize(__middle, __last, __buffer,
          __buffer_size, __comp);
   std::__merge_adaptive_resize(__first, __middle, __last,
           _Distance(__middle - __first),
           _Distance(__last - __middle),
           __buffer, __buffer_size,
           __comp);
 }
      else
 std::__stable_sort_adaptive(__first, __middle, __last,
        __buffer, __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>

    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 2779 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    constexpr
    bool
    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     return false;
   if (!__comp(__first1, __first2))
     ++__first2;
   ++__first1;
 }

      return __first2 == __last2;
    }
# 2817 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {
# 2832 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 2862 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
    {
# 2879 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 2898 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    constexpr
    bool
    __next_permutation(_BidirectionalIterator __first,
         _BidirectionalIterator __last, _Compare __comp)
    {
      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(__i, __ii))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(__i, --__j))
  {}
       std::iter_swap(__i, __j);
       std::__reverse(__ii, __last,
        std::__iterator_category(__first));
       return true;
     }
   if (__i == __first)
     {
       std::__reverse(__first, __last,
        std::__iterator_category(__first));
       return false;
     }
 }
    }
# 2948 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {





                                                     ;
                                                     ;

      return std::__next_permutation
 (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 2981 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    constexpr
    inline bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {






                                                     ;
                                                                  ;

      return std::__next_permutation
 (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _BidirectionalIterator, typename _Compare>
    constexpr
    bool
    __prev_permutation(_BidirectionalIterator __first,
         _BidirectionalIterator __last, _Compare __comp)
    {
      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(__ii, __i))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(--__j, __i))
  {}
       std::iter_swap(__i, __j);
       std::__reverse(__ii, __last,
        std::__iterator_category(__first));
       return true;
     }
   if (__i == __first)
     {
       std::__reverse(__first, __last,
        std::__iterator_category(__first));
       return false;
     }
 }
    }
# 3051 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {





                                                     ;
                                                     ;

      return std::__prev_permutation(__first, __last,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 3084 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    constexpr
    inline bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {






                                                     ;
                                                                  ;

      return std::__prev_permutation(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    constexpr
    _OutputIterator
    __replace_copy_if(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result,
        _Predicate __pred, const _Tp& __new_value)
    {
      for (; __first != __last; ++__first, (void)++__result)
 if (__pred(__first))
   *__result = __new_value;
 else
   *__result = *__first;
      return __result;
    }
# 3136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    constexpr
    inline _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {






                                                     ;

      return std::__replace_copy_if(__first, __last, __result,
   __gnu_cxx::__ops::__iter_equals_val(__old_value),
           __new_value);
    }
# 3171 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    constexpr
    inline _OutputIterator
    replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
    {






                                                     ;

      return std::__replace_copy_if(__first, __last, __result,
    __gnu_cxx::__ops::__pred_iter(__pred),
           __new_value);
    }
# 3200 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
    { return std::is_sorted_until(__first, __last) == __last; }
# 3215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    { return std::is_sorted_until(__first, __last, __comp) == __last; }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
        _Compare __comp)
    {
      if (__first == __last)
 return __last;

      _ForwardIterator __next = __first;
      for (++__next; __next != __last; __first = __next, (void)++__next)
 if (__comp(__next, __first))
   return __next;
      return __next;
    }
# 3246 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 3271 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 3297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b)
    {



      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }
# 3318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {
      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    pair<_ForwardIterator, _ForwardIterator>
    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    {
      _ForwardIterator __next = __first;
      if (__first == __last
   || ++__next == __last)
 return std::make_pair(__first, __first);

      _ForwardIterator __min{}, __max{};
      if (__comp(__next, __first))
 {
   __min = __next;
   __max = __first;
 }
      else
 {
   __min = __first;
   __max = __next;
 }

      __first = __next;
      ++__first;

      while (__first != __last)
 {
   __next = __first;
   if (++__next == __last)
     {
       if (__comp(__first, __min))
  __min = __first;
       else if (!__comp(__first, __max))
  __max = __first;
       break;
     }

   if (__comp(__next, __first))
     {
       if (__comp(__next, __min))
  __min = __next;
       if (!__comp(__first, __max))
  __max = __first;
     }
   else
     {
       if (__comp(__first, __min))
  __min = __first;
       if (!__comp(__next, __max))
  __max = __next;
     }

   __first = __next;
   ++__first;
 }

      return std::make_pair(__min, __max);
    }
# 3398 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 3426 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l)
    {
                                                            ;
      pair<const _Tp*, const _Tp*> __p =
 std::__minmax_element(__l.begin(), __l.end(),
         __gnu_cxx::__ops::__iter_less_iter());
      return std::make_pair(*__p.first, *__p.second);
    }

  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      pair<const _Tp*, const _Tp*> __p =
 std::__minmax_element(__l.begin(), __l.end(),
         __gnu_cxx::__ops::__iter_comp_iter(__comp));
      return std::make_pair(*__p.first, *__p.second);
    }
# 3482 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {






                                                       ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
       _BinaryPredicate __pred)
    {
      using _Cat1
 = typename iterator_traits<_ForwardIterator1>::iterator_category;
      using _Cat2
 = typename iterator_traits<_ForwardIterator2>::iterator_category;
      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
      constexpr bool __ra_iters = __and_<_It1_is_RA, _It2_is_RA>::value;
      if constexpr (__ra_iters)
 {
   if ((__last1 - __first1) != (__last2 - __first2))
     return false;
 }



      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if constexpr (__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;
    }
#pragma GCC diagnostic pop
# 3578 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {
                                                       ;
                                                       ;

      return
 std::__is_permutation(__first1, __last1, __first2, __last2,
         __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 3606 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
    {
                                                       ;
                                                       ;

      return std::__is_permutation(__first1, __last1, __first2, __last2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }
# 3634 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _Tp>
    [[nodiscard]] constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
    {
      do { if (std::__is_constant_evaluated() && !bool(!(__hi < __lo))) std::__glibcxx_assert_fail(); } while (false);
      return std::min(std::max(__val, __lo), __hi);
    }
# 3654 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    [[nodiscard]] constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
    {
      do { if (std::__is_constant_evaluated() && !bool(!__comp(__hi, __lo))) std::__glibcxx_assert_fail(); } while (false);
      return std::min(std::max(__val, __lo, __comp), __hi, __comp);
    }
# 3684 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }
# 3706 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)));
    }
# 3789 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
    constexpr
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {


                                                     ;
      for (; __first != __last; ++__first)
 __f(*__first);
      return __f;
    }
# 3815 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _Function>
    constexpr
    _InputIterator
    for_each_n(_InputIterator __first, _Size __n, _Function __f)
    {
      auto __n2 = std::__size_to_integer(__n);
      using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
      if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
 {
   if (__n2 <= 0)
     return __first;
   auto __last = __first + __n2;
   std::for_each(__first, __last, std::move(__f));
   return __last;
 }
      else
 {
   while (__n2-->0)
     {
       __f(*__first);
       ++__first;
     }
   return __first;
 }
    }
# 3851 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last, const _Tp& __val)
    {




                                                     ;


      using _ValT = typename iterator_traits<_InputIterator>::value_type;
      if constexpr (__can_use_memchr_for_find<_ValT, _Tp>)
 if constexpr (is_pointer_v<decltype(std::__niter_base(__first))>

   || contiguous_iterator<_InputIterator>

       )
   {




     if (!(static_cast<_ValT>(__val) == __val))
       return __last;
     else if (!__is_constant_evaluated())
       {
  const int __ival = static_cast<int>(__val);
  if (auto __n = __last - __first; __n > 0)
    {

      const void* __p0 = std::to_address(__first);



      if (auto __p1 = __builtin_memchr(__p0, __ival, __n))
        return __first + ((const char*)__p1 - (const char*)__p0);
    }
  return __last;
       }
   }


      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 3909 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {




                                                     ;

      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 3941 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2)
    {






                                                       ;
                                                       ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (*__first1 == *__iter)
     return __first1;
      return __last1;
    }
# 3982 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2,
    _BinaryPredicate __comp)
    {






                                                       ;
                                                       ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (__comp(*__first1, *__iter))
     return __first1;
      return __last1;
    }
# 4015 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;

      return std::__adjacent_find(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 4041 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {





                                                     ;

      return std::__adjacent_find(__first, __last,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }
# 4067 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {




                                                     ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 4091 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {




                                                     ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 4132 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 4166 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val)
    {




                                                     ;

      return std::__search_n(__first, __last, __count,
        __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 4200 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {




                                                     ;

      return std::__search_n(__first, __last, __count,
  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
    }
# 4226 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Searcher>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search(_ForwardIterator __first, _ForwardIterator __last,
    const _Searcher& __searcher)
    { return __searcher(__first, __last).first; }
# 4250 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _UnaryOperation>
    constexpr
    _OutputIterator
    transform(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _UnaryOperation __unary_op)
    {





                                                     ;

      for (; __first != __last; ++__first, (void)++__result)
 *__result = __unary_op(*__first);
      return __result;
    }
# 4288 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _BinaryOperation>
    constexpr
    _OutputIterator
    transform(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _OutputIterator __result,
       _BinaryOperation __binary_op)
    {






                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
 *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 4322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    constexpr
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
     const _Tp& __old_value, const _Tp& __new_value)
    {







                                                     ;

      for (; __first != __last; ++__first)
 if (*__first == __old_value)
   *__first = __new_value;
    }
# 4355 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    constexpr
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
        _Predicate __pred, const _Tp& __new_value)
    {







                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   *__first = __new_value;
    }
# 4387 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    constexpr
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {




                                                     ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4420 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
    constexpr
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {





      typedef __decltype(std::__size_to_integer(__n)) _IntSize;
      for (_IntSize __niter = std::__size_to_integer(__n);
    __niter > 0; --__niter, (void) ++__first)
 *__first = __gen();
      return __first;
    }
# 4455 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {






                                                     ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
    __gnu_cxx::__ops::__iter_equal_to_iter(),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4495 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {




                                                     ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4534 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    inline void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {



                                                     ;

      if (__first == __last)
 return;
# 4569 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {

   _RandomAccessIterator __j = __first
     + (std::rand() % ((__i - __first) + 1));
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
    }
# 4597 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,

     _RandomNumberGenerator&& __rand)



    {



                                                     ;

      if (__first == __last)
 return;
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
    }
# 4639 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }
# 4674 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {





                                                       ;
                                                      ;
                                                     ;

      std::__partial_sort(__first, __middle, __last,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 4713 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {






                                                       ;
                                                      ;
                                                                  ;

      std::__partial_sort(__first, __middle, __last,
     __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 4750 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {





                                                    ;
                                                   ;
                                                     ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 4790 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Compare __comp)
    {






                                                    ;
                                                   ;
                                                                  ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 4828 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 4859 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {






                                                     ;
                                                                  ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    _OutputIterator
    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 4922 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {
# 4940 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__merge(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 4973 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {
# 4991 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__merge(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _RandomAccessIterator, typename _Compare>

    inline void
    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      if (__first == __last)
 return;
# 5022 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;


      _TmpBuf __buf(__first, (__last - __first + 1) / 2);

      if (__builtin_expect(__buf.requested_size() == __buf.size(), true))
 std::__stable_sort_adaptive(__first,
        __first + _DistanceType(__buf.size()),
        __last, __buf.begin(), __comp);
      else if (__builtin_expect(__buf.begin() == 0, false))
 std::__inplace_stable_sort(__first, __last, __comp);
      else
 std::__stable_sort_adaptive_resize(__first, __last, __buf.begin(),
        _DistanceType(__buf.size()), __comp);



    }
# 5058 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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());
    }
# 5093 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>

    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {






                                                     ;
                                                                  ;

      std::__stable_sort(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    constexpr
    _OutputIterator
    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
  _InputIterator2 __first2, _InputIterator2 __last2,
  _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first1, __first2))
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5164 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
# 5185 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
# 5236 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    constexpr
    _OutputIterator
    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
         _InputIterator2 __first2, _InputIterator2 __last2,
         _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   ++__first1;
 else if (__comp(__first2, __first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5288 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
# 5307 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_intersection(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 5338 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
# 5357 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_intersection(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    constexpr
    _OutputIterator
    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(__first2, __first1))
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5413 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {
# 5432 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 5465 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
# 5484 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    constexpr
    _OutputIterator
    __set_symmetric_difference(_InputIterator1 __first1,
          _InputIterator1 __last1,
          _InputIterator2 __first2,
          _InputIterator2 __last2,
          _OutputIterator __result,
          _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5546 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {
# 5567 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_symmetric_difference(__first1, __last1,
     __first2, __last2, __result,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 5598 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {
# 5620 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_symmetric_difference(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __min_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__first, __result))
   __result = __first;
      return __result;
    }
# 5652 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    _ForwardIterator
    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5677 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __max_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__result, __first))
   __result = __first;
      return __result;
    }
# 5716 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5741 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _Tp>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l)
    {
                                                            ;
      return *std::__min_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_less_iter());
    }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      return *std::__min_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _Tp>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l)
    {
                                                            ;
      return *std::__max_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_less_iter());
    }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      return *std::__max_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _InputIterator, typename _RandomAccessIterator,
           typename _Size, typename _UniformRandomBitGenerator>
    _RandomAccessIterator
    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
      _RandomAccessIterator __out, random_access_iterator_tag,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      __distrib_type __d{};
      _Size __sample_sz = 0;
      while (__first != __last && __sample_sz != __n)
 {
   __out[__sample_sz++] = *__first;
   ++__first;
 }
      for (auto __pop_sz = __sample_sz; __first != __last;
   ++__first, (void) ++__pop_sz)
 {
   const auto __k = __d(__g, __param_type{0, __pop_sz});
   if (__k < __n)
     __out[__k] = *__first;
 }
      return __out + __sample_sz;
    }


  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
           typename _Size, typename _UniformRandomBitGenerator>
    _OutputIterator
    __sample(_ForwardIterator __first, _ForwardIterator __last,
      forward_iterator_tag,
      _OutputIterator __out, _Cat,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      using _USize = make_unsigned_t<_Size>;
      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

      if (__first == __last)
 return __out;

      __distrib_type __d{};
      _Size __unsampled_sz = std::distance(__first, __last);
      __n = std::min(__n, __unsampled_sz);




      const __uc_type __urngrange = __g.max() - __g.min();
      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))


        {
   while (__n != 0 && __unsampled_sz >= 2)
     {
       const pair<_Size, _Size> __p =
  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

       --__unsampled_sz;
       if (__p.first < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;

       if (__n == 0) break;

       --__unsampled_sz;
       if (__p.second < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;
     }
        }



      for (; __n != 0; ++__first)
 if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
   {
     *__out++ = *__first;
     --__n;
   }
      return __out;
    }




  template<typename _PopulationIterator, typename _SampleIterator,
           typename _Distance, typename _UniformRandomBitGenerator>
    _SampleIterator
    sample(_PopulationIterator __first, _PopulationIterator __last,
    _SampleIterator __out, _Distance __n,
    _UniformRandomBitGenerator&& __g)
    {
      using __pop_cat = typename
 std::iterator_traits<_PopulationIterator>::iterator_category;
      using __samp_cat = typename
 std::iterator_traits<_SampleIterator>::iterator_category;

      static_assert(
   __or_<is_convertible<__pop_cat, forward_iterator_tag>,
  is_convertible<__samp_cat, random_access_iterator_tag>>::value,
   "output range must use a RandomAccessIterator when input range"
   " does not meet the ForwardIterator requirements");

      static_assert(is_integral<_Distance>::value,
      "sample size must be an integer type");

      typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
      return std::
 __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
   std::forward<_UniformRandomBitGenerator>(__g));
    }




}

#pragma GCC diagnostic pop
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algo.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algo.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Comp, typename _Proj>
      constexpr auto
      __make_comp_proj(_Comp& __comp, _Proj& __proj)
      {
 return [&] (auto&& __lhs, auto&& __rhs) -> bool {
   using _TL = decltype(__lhs);
   using _TR = decltype(__rhs);
   return std::__invoke(__comp,
          std::__invoke(__proj, std::forward<_TL>(__lhs)),
          std::__invoke(__proj, std::forward<_TR>(__rhs)));
 };
      }

    template<typename _Pred, typename _Proj>
      constexpr auto
      __make_pred_proj(_Pred& __pred, _Proj& __proj)
      {
 return [&] <typename _Tp> (_Tp&& __arg) -> bool {
   return std::__invoke(__pred,
          std::__invoke(__proj, std::forward<_Tp>(__arg)));
 };
      }
  }

  struct __all_of_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (!(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
     return false;
 return true;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr bool
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __all_of_fn all_of{};

  struct __any_of_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     return true;
 return false;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr bool
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __any_of_fn any_of{};

  struct __none_of_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     return false;
 return true;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr bool
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __none_of_fn none_of{};

  template<typename _Iter, typename _Fp>
    struct in_fun_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Fp fun;

      template<typename _Iter2, typename _F2p>
 requires convertible_to<const _Iter&, _Iter2>
   && convertible_to<const _Fp&, _F2p>
 constexpr
 operator in_fun_result<_Iter2, _F2p>() const &
 { return {in, fun}; }

      template<typename _Iter2, typename _F2p>
 requires convertible_to<_Iter, _Iter2> && convertible_to<_Fp, _F2p>
 constexpr
 operator in_fun_result<_Iter2, _F2p>() &&
 { return {std::move(in), std::move(fun)}; }
    };

  template<typename _Iter, typename _Fp>
    using for_each_result = in_fun_result<_Iter, _Fp>;

  struct __for_each_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirectly_unary_invocable<projected<_Iter, _Proj>> _Fun>
      constexpr for_each_result<_Iter, _Fun>
      operator()(_Iter __first, _Sent __last, _Fun __f, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   std::__invoke(__f, std::__invoke(__proj, *__first));
 return { std::move(__first), std::move(__f) };
      }

    template<input_range _Range, typename _Proj = identity,
      indirectly_unary_invocable<projected<iterator_t<_Range>, _Proj>>
        _Fun>
      constexpr for_each_result<borrowed_iterator_t<_Range>, _Fun>
      operator()(_Range&& __r, _Fun __f, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__f), std::move(__proj));
      }
  };

  inline constexpr __for_each_fn for_each{};

  template<typename _Iter, typename _Fp>
    using for_each_n_result = in_fun_result<_Iter, _Fp>;

  struct __for_each_n_fn
  {
    template<input_iterator _Iter, typename _Proj = identity,
      indirectly_unary_invocable<projected<_Iter, _Proj>> _Fun>
      constexpr for_each_n_result<_Iter, _Fun>
      operator()(_Iter __first, iter_difference_t<_Iter> __n,
   _Fun __f, _Proj __proj = {}) const
      {
 if constexpr (random_access_iterator<_Iter>)
   {
     if (__n <= 0)
       return {std::move(__first), std::move(__f)};
     auto __last = __first + __n;
     return ranges::for_each(std::move(__first), std::move(__last),
        std::move(__f), std::move(__proj));
   }
 else
   {
     while (__n-- > 0)
       {
  std::__invoke(__f, std::__invoke(__proj, *__first));
  ++__first;
       }
     return {std::move(__first), std::move(__f)};
   }
      }
  };

  inline constexpr __for_each_n_fn for_each_n{};



  struct __find_first_of_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr _Iter1
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 for (; __first1 != __last1; ++__first1)
   for (auto __iter = __first2; __iter != __last2; ++__iter)
     if (std::__invoke(__pred,
         std::__invoke(__proj1, *__first1),
         std::__invoke(__proj2, *__iter)))
       return __first1;
 return __first1;
      }

    template<input_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_iterator_t<_Range1>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __find_first_of_fn find_first_of{};

  struct __count_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp >
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>,
      const _Tp*>
      constexpr iter_difference_t<_Iter>
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Proj __proj = {}) const
      {
 iter_difference_t<_Iter> __n = 0;
 for (; __first != __last; ++__first)
   if (std::__invoke(__proj, *__first) == __value)
     ++__n;
 return __n;
      }

    template<input_range _Range, typename _Proj = identity,
      typename _Tp
                                                                  >
      requires indirect_binary_predicate<ranges::equal_to,
      projected<iterator_t<_Range>, _Proj>,
      const _Tp*>
      constexpr range_difference_t<_Range>
      operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__proj));
      }
  };

  inline constexpr __count_fn count{};

  struct __count_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr iter_difference_t<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 iter_difference_t<_Iter> __n = 0;
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     ++__n;
 return __n;
      }

    template<input_range _Range,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr range_difference_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __count_if_fn count_if{};



  struct __search_n_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Pred = ranges::equal_to, typename _Proj = identity,
      typename _Tp >
      requires indirectly_comparable<_Iter, const _Tp*, _Pred, _Proj>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last, iter_difference_t<_Iter> __count,
   const _Tp& __value, _Pred __pred = {}, _Proj __proj = {}) const
      {
 if (__count <= 0)
   return {__first, __first};

 auto __value_comp = [&] <typename _Rp> (_Rp&& __arg) -> bool {
     return std::__invoke(__pred, std::forward<_Rp>(__arg), __value);
 };
 if (__count == 1)
   {
     __first = ranges::find_if(std::move(__first), __last,
          std::move(__value_comp),
          std::move(__proj));
     if (__first == __last)
       return {__first, __first};
     else
       {
  auto __end = __first;
  return {__first, ++__end};
       }
   }

 if constexpr (sized_sentinel_for<_Sent, _Iter>
        && random_access_iterator<_Iter>)
   {
     auto __tail_size = __last - __first;
     auto __remainder = __count;

     while (__remainder <= __tail_size)
       {
  __first += __remainder;
  __tail_size -= __remainder;
  auto __backtrack = __first;
  while (__value_comp(std::__invoke(__proj, *--__backtrack)))
    {
      if (--__remainder == 0)
        return {__first - __count, __first};
    }
  __remainder = __count + 1 - (__first - __backtrack);
       }
     auto __i = __first + __tail_size;
     return {__i, __i};
   }
 else
   {
     __first = ranges::find_if(__first, __last, __value_comp, __proj);
     while (__first != __last)
       {
  auto __n = __count;
  auto __i = __first;
  ++__i;
  while (__i != __last && __n != 1
         && __value_comp(std::__invoke(__proj, *__i)))
    {
      ++__i;
      --__n;
    }
  if (__n == 1)
    return {__first, __i};
  if (__i == __last)
    return {__i, __i};
  __first = ranges::find_if(++__i, __last, __value_comp, __proj);
       }
     return {__first, __first};
   }
      }

    template<forward_range _Range,
      typename _Pred = ranges::equal_to, typename _Proj = identity,
      typename _Tp
                                                                  >
      requires indirectly_comparable<iterator_t<_Range>, const _Tp*,
         _Pred, _Proj>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, range_difference_t<_Range> __count,
        const _Tp& __value, _Pred __pred = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__count), __value,
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __search_n_fn search_n{};

  struct __find_end_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr subrange<_Iter1>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if constexpr (bidirectional_iterator<_Iter1>
        && bidirectional_iterator<_Iter2>)
   {
     auto __i1 = ranges::next(__first1, __last1);
     auto __i2 = ranges::next(__first2, __last2);
     auto __rresult
       = ranges::search(reverse_iterator<_Iter1>{__i1},
          reverse_iterator<_Iter1>{__first1},
          reverse_iterator<_Iter2>{__i2},
          reverse_iterator<_Iter2>{__first2},
          std::move(__pred),
          std::move(__proj1), std::move(__proj2));
     auto __result_first = ranges::end(__rresult).base();
     auto __result_last = ranges::begin(__rresult).base();
     if (__result_last == __first1)
       return {__i1, __i1};
     else
       return {__result_first, __result_last};
   }
 else
   {
     auto __i = ranges::next(__first1, __last1);
     if (__first2 == __last2)
       return {__i, __i};

     auto __result_begin = __i;
     auto __result_end = __i;
     for (;;)
       {
  auto __new_range = ranges::search(__first1, __last1,
        __first2, __last2,
        __pred, __proj1, __proj2);
  auto __new_result_begin = ranges::begin(__new_range);
  auto __new_result_end = ranges::end(__new_range);
  if (__new_result_begin == __last1)
    return {__result_begin, __result_end};
  else
    {
      __result_begin = __new_result_begin;
      __result_end = __new_result_end;
      __first1 = __result_begin;
      ++__first1;
    }
       }
   }
      }

    template<forward_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_subrange_t<_Range1>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __find_end_fn find_end{};



  struct __is_permutation_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_equivalence_relation<projected<_Iter1, _Proj1>,
        projected<_Iter2, _Proj2>> _Pred
        = ranges::equal_to>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 constexpr bool __sized_iters
   = (sized_sentinel_for<_Sent1, _Iter1>
      && sized_sentinel_for<_Sent2, _Iter2>);
 if constexpr (__sized_iters)
   {
     auto __d1 = ranges::distance(__first1, __last1);
     auto __d2 = ranges::distance(__first2, __last2);
     if (__d1 != __d2)
       return false;
   }



 for (; __first1 != __last1 && __first2 != __last2;
      ++__first1, (void)++__first2)
   if (!(bool)std::__invoke(__pred,
       std::__invoke(__proj1, *__first1),
       std::__invoke(__proj2, *__first2)))
       break;

 if constexpr (__sized_iters)
   {
     if (__first1 == __last1)
       return true;
   }
 else
   {
     auto __d1 = ranges::distance(__first1, __last1);
     auto __d2 = ranges::distance(__first2, __last2);
     if (__d1 == 0 && __d2 == 0)
       return true;
     if (__d1 != __d2)
       return false;
   }

 for (auto __scan = __first1; __scan != __last1; ++__scan)
   {
     auto&& __scan_deref = *__scan;
     auto&& __proj_scan =
       std::__invoke(__proj1, std::forward<decltype(__scan_deref)>(__scan_deref));
     auto __comp_scan = [&] <typename _Tp> (_Tp&& __arg) -> bool {
       return std::__invoke(__pred,
       std::forward<decltype(__proj_scan)>(__proj_scan),
       std::forward<_Tp>(__arg));
     };
     if (__scan != ranges::find_if(__first1, __scan,
       __comp_scan, __proj1))
       continue;

     auto __matches = ranges::count_if(__first2, __last2,
           __comp_scan, __proj2);
     if (__matches == 0
  || ranges::count_if(__scan, __last1,
        __comp_scan, __proj1) != __matches)
       return false;
   }
 return true;
      }

    template<forward_range _Range1, forward_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range1>, _Proj1>,
        projected<iterator_t<_Range2>, _Proj2>> _Pred = ranges::equal_to>
      constexpr bool
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {


 if constexpr (sized_range<_Range1>)
   if constexpr (sized_range<_Range2>)
     if (ranges::distance(__r1) != ranges::distance(__r2))
       return false;

 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __is_permutation_fn is_permutation{};

  template<typename _Iter, typename _Out>
    using copy_if_result = in_out_result<_Iter, _Out>;

  struct __copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_copyable<_Iter, _Out>
      constexpr copy_if_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     {
       *__result = *__first;
       ++__result;
     }
 return {std::move(__first), std::move(__result)};
      }

    template<input_range _Range, weakly_incrementable _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr copy_if_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __copy_if_fn copy_if{};

  template<typename _Iter1, typename _Iter2>
    using swap_ranges_result = in_in_result<_Iter1, _Iter2>;

  struct __swap_ranges_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2>
      requires indirectly_swappable<_Iter1, _Iter2>
      constexpr swap_ranges_result<_Iter1, _Iter2>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2) const
      {
 for (; __first1 != __last1 && __first2 != __last2;
      ++__first1, (void)++__first2)
   ranges::iter_swap(__first1, __first2);
 return {std::move(__first1), std::move(__first2)};
      }

    template<input_range _Range1, input_range _Range2>
      requires indirectly_swappable<iterator_t<_Range1>, iterator_t<_Range2>>
      constexpr swap_ranges_result<borrowed_iterator_t<_Range1>,
       borrowed_iterator_t<_Range2>>
      operator()(_Range1&& __r1, _Range2&& __r2) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2));
      }
  };

  inline constexpr __swap_ranges_fn swap_ranges{};

  template<typename _Iter, typename _Out>
    using unary_transform_result = in_out_result<_Iter, _Out>;

  template<typename _Iter1, typename _Iter2, typename _Out>
    struct in_in_out_result
    {
      [[no_unique_address]] _Iter1 in1;
      [[no_unique_address]] _Iter2 in2;
      [[no_unique_address]] _Out out;

      template<typename _IIter1, typename _IIter2, typename _OOut>
 requires convertible_to<const _Iter1&, _IIter1>
   && convertible_to<const _Iter2&, _IIter2>
   && convertible_to<const _Out&, _OOut>
 constexpr
 operator in_in_out_result<_IIter1, _IIter2, _OOut>() const &
 { return {in1, in2, out}; }

      template<typename _IIter1, typename _IIter2, typename _OOut>
 requires convertible_to<_Iter1, _IIter1>
   && convertible_to<_Iter2, _IIter2>
   && convertible_to<_Out, _OOut>
 constexpr
 operator in_in_out_result<_IIter1, _IIter2, _OOut>() &&
 { return {std::move(in1), std::move(in2), std::move(out)}; }
    };

  template<typename _Iter1, typename _Iter2, typename _Out>
    using binary_transform_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __transform_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out,
      copy_constructible _Fp, typename _Proj = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<_Iter, _Proj>>>
      constexpr unary_transform_result<_Iter, _Out>
      operator()(_Iter __first1, _Sent __last1, _Out __result,
   _Fp __op, _Proj __proj = {}) const
      {
 for (; __first1 != __last1; ++__first1, (void)++__result)
   *__result = std::__invoke(__op, std::__invoke(__proj, *__first1));
 return {std::move(__first1), std::move(__result)};
      }

    template<input_range _Range, weakly_incrementable _Out,
      copy_constructible _Fp, typename _Proj = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<iterator_t<_Range>, _Proj>>>
      constexpr unary_transform_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result, _Fp __op, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result),
         std::move(__op), std::move(__proj));
      }

    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, copy_constructible _Fp,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<_Iter1, _Proj1>,
         projected<_Iter2, _Proj2>>>
      constexpr binary_transform_result<_Iter1, _Iter2, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2,
   _Out __result, _Fp __binary_op,
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 for (; __first1 != __last1 && __first2 != __last2;
      ++__first1, (void)++__first2, ++__result)
   *__result = std::__invoke(__binary_op,
        std::__invoke(__proj1, *__first1),
        std::__invoke(__proj2, *__first2));
 return {std::move(__first1), std::move(__first2), std::move(__result)};
      }

    template<input_range _Range1, input_range _Range2,
      weakly_incrementable _Out, copy_constructible _Fp,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<iterator_t<_Range1>, _Proj1>,
         projected<iterator_t<_Range2>, _Proj2>>>
      constexpr binary_transform_result<borrowed_iterator_t<_Range1>,
     borrowed_iterator_t<_Range2>, _Out>
      operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Fp __binary_op,
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__binary_op),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __transform_fn transform{};

  struct __replace_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp1 ,
      typename _Tp2 >
      requires indirectly_writable<_Iter, const _Tp2&>
 && indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>,
         const _Tp1*>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   const _Tp1& __old_value, const _Tp2& __new_value,
   _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__proj, *__first) == __old_value)
     *__first = __new_value;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      typename _Tp1
                                                                  ,
      typename _Tp2 >
      requires indirectly_writable<iterator_t<_Range>, const _Tp2&>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp1*>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r,
   const _Tp1& __old_value, const _Tp2& __new_value,
   _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __old_value, __new_value, std::move(__proj));
      }
  };

  inline constexpr __replace_fn replace{};

  struct __replace_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp ,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_writable<_Iter, const _Tp&>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     *__first = __new_value;
 return std::move(__first);
      }

    template<input_range _Range, typename _Proj = identity,
      typename _Tp
                                                                  ,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_writable<iterator_t<_Range>, const _Tp&>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r,
   _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), __new_value, std::move(__proj));
      }
  };

  inline constexpr __replace_if_fn replace_if{};

  template<typename _Iter, typename _Out>
    using replace_copy_result = in_out_result<_Iter, _Out>;

  struct __replace_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Out, typename _Proj = identity,
      typename _Tp1 ,
      typename _Tp2 >
      requires indirectly_copyable<_Iter, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<_Iter, _Proj>, const _Tp1*>
 && output_iterator<_Out, const _Tp2&>
      constexpr replace_copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   const _Tp1& __old_value, const _Tp2& __new_value,
   _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first, (void)++__result)
   if (std::__invoke(__proj, *__first) == __old_value)
     *__result = __new_value;
   else
     *__result = *__first;
 return {std::move(__first), std::move(__result)};
      }

    template<input_range _Range, typename _Out,
      typename _Proj = identity,
      typename _Tp1
                                                                  ,
      typename _Tp2 >
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp1*>
 && output_iterator<_Out, const _Tp2&>
      constexpr replace_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   const _Tp1& __old_value, const _Tp2& __new_value,
   _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result), __old_value,
         __new_value, std::move(__proj));
      }
  };

  inline constexpr __replace_copy_fn replace_copy{};

  template<typename _Iter, typename _Out>
    using replace_copy_if_result = in_out_result<_Iter, _Out>;

  struct __replace_copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Out,
      typename _Tp ,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_copyable<_Iter, _Out>
 && output_iterator<_Out, const _Tp&>
      constexpr replace_copy_if_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first, (void)++__result)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     *__result = __new_value;
   else
     *__result = *__first;
 return {std::move(__first), std::move(__result)};
      }

    template<input_range _Range,
      typename _Out,
      typename _Tp ,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && output_iterator<_Out, const _Tp&>
      constexpr replace_copy_if_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result), std::move(__pred),
         __new_value, std::move(__proj));
      }
  };

  inline constexpr __replace_copy_if_fn replace_copy_if{};

  struct __generate_n_fn
  {
    template<input_or_output_iterator _Out, copy_constructible _Fp>
      requires invocable<_Fp&>
 && indirectly_writable<_Out, invoke_result_t<_Fp&>>
      constexpr _Out
      operator()(_Out __first, iter_difference_t<_Out> __n, _Fp __gen) const
      {
 for (; __n > 0; --__n, (void)++__first)
   *__first = std::__invoke(__gen);
 return __first;
      }
  };

  inline constexpr __generate_n_fn generate_n{};

  struct __generate_fn
  {
    template<input_or_output_iterator _Out, sentinel_for<_Out> _Sent,
      copy_constructible _Fp>
      requires invocable<_Fp&>
 && indirectly_writable<_Out, invoke_result_t<_Fp&>>
      constexpr _Out
      operator()(_Out __first, _Sent __last, _Fp __gen) const
      {
 for (; __first != __last; ++__first)
   *__first = std::__invoke(__gen);
 return __first;
      }

    template<typename _Range, copy_constructible _Fp>
      requires invocable<_Fp&> && output_range<_Range, invoke_result_t<_Fp&>>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Fp __gen) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__gen));
      }
  };

  inline constexpr __generate_fn generate{};

  struct __remove_if_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 __first = ranges::find_if(__first, __last, __pred, __proj);
 if (__first == __last)
   return {__first, __first};

 auto __result = __first;
 ++__first;
 for (; __first != __last; ++__first)
   if (!std::__invoke(__pred, std::__invoke(__proj, *__first)))
     {
       *__result = std::move(*__first);
       ++__result;
     }

 return {__result, __first};
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __remove_if_fn remove_if{};

  struct __remove_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp >
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>,
      const _Tp*>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Proj __proj = {}) const
      {
 auto __pred = [&] (auto&& __arg) -> bool {
   return std::forward<decltype(__arg)>(__arg) == __value;
 };
 return ranges::remove_if(__first, __last,
     std::move(__pred), std::move(__proj));
      }

    template<forward_range _Range, typename _Proj = identity,
      typename _Tp
                                                                  >
      requires permutable<iterator_t<_Range>>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp*>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__proj));
      }
  };

  inline constexpr __remove_fn remove{};

  template<typename _Iter, typename _Out>
    using remove_copy_if_result = in_out_result<_Iter, _Out>;

  struct __remove_copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_copyable<_Iter, _Out>
      constexpr remove_copy_if_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (!std::__invoke(__pred, std::__invoke(__proj, *__first)))
     {
       *__result = *__first;
       ++__result;
     }
 return {std::move(__first), std::move(__result)};
      }

    template<input_range _Range, weakly_incrementable _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr remove_copy_if_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __remove_copy_if_fn remove_copy_if{};

  template<typename _Iter, typename _Out>
    using remove_copy_result = in_out_result<_Iter, _Out>;

  struct __remove_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      typename _Tp >
      requires indirectly_copyable<_Iter, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<_Iter, _Proj>,
         const _Tp*>
      constexpr remove_copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   const _Tp& __value, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (!(std::__invoke(__proj, *__first) == __value))
     {
       *__result = *__first;
       ++__result;
     }
 return {std::move(__first), std::move(__result)};
      }

    template<input_range _Range, weakly_incrementable _Out,
      typename _Proj = identity,
      typename _Tp
                                                                  >
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp*>
      constexpr remove_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   const _Tp& __value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result), __value, std::move(__proj));
      }
  };

  inline constexpr __remove_copy_fn remove_copy{};

  struct __unique_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_equivalence_relation<
        projected<_Iter, _Proj>> _Comp = ranges::equal_to>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 __first = ranges::adjacent_find(__first, __last, __comp, __proj);
 if (__first == __last)
   return {__first, __first};

 auto __dest = __first;
 ++__first;
 while (++__first != __last)
   if (!std::__invoke(__comp,
        std::__invoke(__proj, *__dest),
        std::__invoke(__proj, *__first)))
     *++__dest = std::move(*__first);
 return {++__dest, __first};
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __unique_fn unique{};

  namespace __detail
  {
    template<typename _Out, typename _Tp>
      concept __can_reread_output = input_iterator<_Out>
 && same_as<_Tp, iter_value_t<_Out>>;
  }

  template<typename _Iter, typename _Out>
    using unique_copy_result = in_out_result<_Iter, _Out>;

  struct __unique_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_equivalence_relation<
        projected<_Iter, _Proj>> _Comp = ranges::equal_to>
      requires indirectly_copyable<_Iter, _Out>
 && (forward_iterator<_Iter>
     || __detail::__can_reread_output<_Out, iter_value_t<_Iter>>
     || indirectly_copyable_storable<_Iter, _Out>)
      constexpr unique_copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return {std::move(__first), std::move(__result)};


 if constexpr (forward_iterator<_Iter>)
   {
     auto __next = __first;
     *__result = *__next;
     while (++__next != __last)
       if (!std::__invoke(__comp,
     std::__invoke(__proj, *__first),
     std::__invoke(__proj, *__next)))
  {
    __first = __next;
    *++__result = *__first;
  }
     return {__next, std::move(++__result)};
   }
 else if constexpr (__detail::__can_reread_output<_Out, iter_value_t<_Iter>>)
   {
     *__result = *__first;
     while (++__first != __last)
       if (!std::__invoke(__comp,
     std::__invoke(__proj, *__result),
     std::__invoke(__proj, *__first)))
    *++__result = *__first;
     return {std::move(__first), std::move(++__result)};
   }
 else
   {
     auto __value = *__first;
     *__result = __value;
     while (++__first != __last)
       {
  if (!(bool)std::__invoke(__comp,
      std::__invoke(__proj, *__first),
      std::__invoke(__proj, __value)))
    {
      __value = *__first;
      *++__result = __value;
    }
       }
     return {std::move(__first), std::move(++__result)};
   }
      }

    template<input_range _Range,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && (forward_iterator<iterator_t<_Range>>
     || __detail::__can_reread_output<_Out, range_value_t<_Range>>
     || indirectly_copyable_storable<iterator_t<_Range>, _Out>)
      constexpr unique_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __unique_copy_fn unique_copy{};

  struct __reverse_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent>
      requires permutable<_Iter>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last) const
      {
 auto __i = ranges::next(__first, __last);
 auto __tail = __i;

 if constexpr (random_access_iterator<_Iter>)
   {
     if (__first != __last)
       {
  --__tail;
  while (__first < __tail)
    {
      ranges::iter_swap(__first, __tail);
      ++__first;
      --__tail;
    }
       }
     return __i;
   }
 else
   {
     for (;;)
       if (__first == __tail || __first == --__tail)
  break;
       else
  {
    ranges::iter_swap(__first, __tail);
    ++__first;
  }
     return __i;
   }
      }

    template<bidirectional_range _Range>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r));
      }
  };

  inline constexpr __reverse_fn reverse{};

  template<typename _Iter, typename _Out>
    using reverse_copy_result = in_out_result<_Iter, _Out>;

  struct __reverse_copy_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr reverse_copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result) const
      {
 auto __i = ranges::next(__first, __last);
 auto __tail = __i;
 while (__first != __tail)
   {
     --__tail;
     *__result = *__tail;
     ++__result;
   }
 return {__i, std::move(__result)};
      }

    template<bidirectional_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr reverse_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __reverse_copy_fn reverse_copy{};

  struct __rotate_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _Sent>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Iter __middle, _Sent __last) const
      {
 auto __lasti = ranges::next(__first, __last);
 if (__first == __middle)
   return {__lasti, __lasti};
 if (__last == __middle)
   return {std::move(__first), std::move(__lasti)};

 if constexpr (random_access_iterator<_Iter>)
   {
     auto __n = __lasti - __first;
     auto __k = __middle - __first;

     if (__k == __n - __k)
       {
  ranges::swap_ranges(__first, __middle, __middle, __middle + __k);
  return {std::move(__middle), std::move(__lasti)};
       }

     auto __p = __first;
     auto __ret = __first + (__lasti - __middle);

     for (;;)
       {
  if (__k < __n - __k)
    {


      if constexpr (__is_pod(iter_value_t<_Iter>))
        if (__k == 1)
   {
     auto __t = std::move(*__p);
     ranges::move(__p + 1, __p + __n, __p);
     *(__p + __n - 1) = std::move(__t);
     return {std::move(__ret), std::move(__lasti)};
   }
      auto __q = __p + __k;
      for (decltype(__n) __i = 0; __i < __n - __k; ++ __i)
        {
   ranges::iter_swap(__p, __q);
   ++__p;
   ++__q;
        }
      __n %= __k;
      if (__n == 0)
        return {std::move(__ret), std::move(__lasti)};
      ranges::swap(__n, __k);
      __k = __n - __k;
    }
  else
    {
      __k = __n - __k;


      if constexpr (__is_pod(iter_value_t<_Iter>))
        if (__k == 1)
   {
     auto __t = std::move(*(__p + __n - 1));
     ranges::move_backward(__p, __p + __n - 1, __p + __n);
     *__p = std::move(__t);
     return {std::move(__ret), std::move(__lasti)};
   }
      auto __q = __p + __n;
      __p = __q - __k;
      for (decltype(__n) __i = 0; __i < __n - __k; ++ __i)
        {
   --__p;
   --__q;
   ranges::iter_swap(__p, __q);
        }
      __n %= __k;
      if (__n == 0)
        return {std::move(__ret), std::move(__lasti)};
      std::swap(__n, __k);
    }
       }
   }
 else if constexpr (bidirectional_iterator<_Iter>)
   {
     auto __tail = __lasti;

     ranges::reverse(__first, __middle);
     ranges::reverse(__middle, __tail);

     while (__first != __middle && __middle != __tail)
       {
  ranges::iter_swap(__first, --__tail);
  ++__first;
       }

     if (__first == __middle)
       {
  ranges::reverse(__middle, __tail);
  return {std::move(__tail), std::move(__lasti)};
       }
     else
       {
  ranges::reverse(__first, __middle);
  return {std::move(__first), std::move(__lasti)};
       }
   }
 else
   {
     auto __first2 = __middle;
     do
       {
  ranges::iter_swap(__first, __first2);
  ++__first;
  ++__first2;
  if (__first == __middle)
    __middle = __first2;
       } while (__first2 != __last);

     auto __ret = __first;

     __first2 = __middle;

     while (__first2 != __last)
       {
  ranges::iter_swap(__first, __first2);
  ++__first;
  ++__first2;
  if (__first == __middle)
    __middle = __first2;
  else if (__first2 == __last)
    __first2 = __middle;
       }
     return {std::move(__ret), std::move(__lasti)};
   }
      }

    template<forward_range _Range>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, iterator_t<_Range> __middle) const
      {
 return (*this)(ranges::begin(__r), std::move(__middle),
         ranges::end(__r));
      }
  };

  inline constexpr __rotate_fn rotate{};

  template<typename _Iter, typename _Out>
    using rotate_copy_result = in_out_result<_Iter, _Out>;

  struct __rotate_copy_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr rotate_copy_result<_Iter, _Out>
      operator()(_Iter __first, _Iter __middle, _Sent __last,
   _Out __result) const
      {
 auto __copy1 = ranges::copy(__middle,
        std::move(__last),
        std::move(__result));
 auto __copy2 = ranges::copy(std::move(__first),
        std::move(__middle),
        std::move(__copy1.out));
 return { std::move(__copy1.in), std::move(__copy2.out) };
      }

    template<forward_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr rotate_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, iterator_t<_Range> __middle, _Out __result) const
      {
 return (*this)(ranges::begin(__r), std::move(__middle),
         ranges::end(__r), std::move(__result));
      }
  };

  inline constexpr __rotate_copy_fn rotate_copy{};

  struct __sample_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Gen>
      requires (forward_iterator<_Iter> || random_access_iterator<_Out>)
 && indirectly_copyable<_Iter, _Out>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _Out
      operator()(_Iter __first, _Sent __last, _Out __out,
   iter_difference_t<_Iter> __n, _Gen&& __g) const
      {
 if constexpr (forward_iterator<_Iter>)
   {


     auto __lasti = ranges::next(__first, __last);
     return std::
       sample(std::move(__first), std::move(__lasti), std::move(__out),
       __n, std::forward<_Gen>(__g));
   }
 else
   {
     using __distrib_type
       = uniform_int_distribution<iter_difference_t<_Iter>>;
     using __param_type = typename __distrib_type::param_type;
     __distrib_type __d{};
     iter_difference_t<_Iter> __sample_sz = 0;
     while (__first != __last && __sample_sz != __n)
       {
  __out[__sample_sz++] = *__first;
  ++__first;
       }
     for (auto __pop_sz = __sample_sz; __first != __last;
  ++__first, (void) ++__pop_sz)
       {
  const auto __k = __d(__g, __param_type{0, __pop_sz});
  if (__k < __n)
    __out[__k] = *__first;
       }
     return __out + __sample_sz;
   }
      }

    template<input_range _Range, weakly_incrementable _Out, typename _Gen>
      requires (forward_range<_Range> || random_access_iterator<_Out>)
 && indirectly_copyable<iterator_t<_Range>, _Out>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _Out
      operator()(_Range&& __r, _Out __out,
   range_difference_t<_Range> __n, _Gen&& __g) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__out), __n,
         std::forward<_Gen>(__g));
      }
  };

  inline constexpr __sample_fn sample{};

  struct __shuffle_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Gen>
      requires permutable<_Iter>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _Iter
      operator()(_Iter __first, _Sent __last, _Gen&& __g) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::shuffle(std::move(__first), __lasti, std::forward<_Gen>(__g));
 return __lasti;
      }

    template<random_access_range _Range, typename _Gen>
      requires permutable<iterator_t<_Range>>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Gen&& __g) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::forward<_Gen>(__g));
      }
  };

  inline constexpr __shuffle_fn shuffle{};

  struct __push_heap_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::push_heap(__first, __lasti,
         __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __push_heap_fn push_heap{};

  struct __pop_heap_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::pop_heap(__first, __lasti,
        __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __pop_heap_fn pop_heap{};

  struct __make_heap_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::make_heap(__first, __lasti,
         __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __make_heap_fn make_heap{};

  struct __sort_heap_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::sort_heap(__first, __lasti,
         __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __sort_heap_fn sort_heap{};

  struct __is_heap_until_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 iter_difference_t<_Iter> __n = ranges::distance(__first, __last);
 iter_difference_t<_Iter> __parent = 0, __child = 1;
 for (; __child < __n; ++__child)
   if (std::__invoke(__comp,
       std::__invoke(__proj, *(__first + __parent)),
       std::__invoke(__proj, *(__first + __child))))
     return __first + __child;
   else if ((__child & 1) == 0)
     ++__parent;

 return __first + __n;
      }

    template<random_access_range _Range,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __is_heap_until_fn is_heap_until{};

  struct __is_heap_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (__last
  == ranges::is_heap_until(__first, __last,
      std::move(__comp),
      std::move(__proj)));
      }

    template<random_access_range _Range,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __is_heap_fn is_heap{};

  struct __sort_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::sort(std::move(__first), __lasti,
        __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __sort_fn sort{};

  struct __stable_sort_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>

      _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::stable_sort(std::move(__first), __lasti,
    __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>

      borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __stable_sort_fn stable_sort{};

  struct __partial_sort_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Iter __middle, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __middle)
   return ranges::next(__first, __last);

 ranges::make_heap(__first, __middle, __comp, __proj);
 auto __i = __middle;
 for (; __i != __last; ++__i)
   if (std::__invoke(__comp,
       std::__invoke(__proj, *__i),
       std::__invoke(__proj, *__first)))
     {
       ranges::pop_heap(__first, __middle, __comp, __proj);
       ranges::iter_swap(__middle-1, __i);
       ranges::push_heap(__first, __middle, __comp, __proj);
     }
 ranges::sort_heap(__first, __middle, __comp, __proj);

 return __i;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, iterator_t<_Range> __middle,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), std::move(__middle),
         ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __partial_sort_fn partial_sort{};

  template<typename _Iter, typename _Out>
    using partial_sort_copy_result = in_out_result<_Iter, _Out>;

  struct __partial_sort_copy_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      random_access_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_copyable<_Iter1, _Iter2>
 && sortable<_Iter2, _Comp, _Proj2>
 && indirect_strict_weak_order<_Comp,
          projected<_Iter1, _Proj1>,
          projected<_Iter2, _Proj2>>
      constexpr partial_sort_copy_result<_Iter1, _Iter2>
      operator()(_Iter1 __first, _Sent1 __last,
   _Iter2 __result_first, _Sent2 __result_last,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if (__result_first == __result_last)
   {

     auto __lasti = ranges::next(std::move(__first),
     std::move(__last));
     return {std::move(__lasti), std::move(__result_first)};
   }

 auto __result_real_last = __result_first;
 while (__first != __last && __result_real_last != __result_last)
   {
     *__result_real_last = *__first;
     ++__result_real_last;
     ++__first;
   }

 ranges::make_heap(__result_first, __result_real_last, __comp, __proj2);
 for (; __first != __last; ++__first)
   if (std::__invoke(__comp,
       std::__invoke(__proj1, *__first),
       std::__invoke(__proj2, *__result_first)))
     {
       ranges::pop_heap(__result_first, __result_real_last,
          __comp, __proj2);
       *(__result_real_last-1) = *__first;
       ranges::push_heap(__result_first, __result_real_last,
    __comp, __proj2);
     }
 ranges::sort_heap(__result_first, __result_real_last, __comp, __proj2);

 return {std::move(__first), std::move(__result_real_last)};
      }

    template<input_range _Range1, random_access_range _Range2,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_copyable<iterator_t<_Range1>, iterator_t<_Range2>>
 && sortable<iterator_t<_Range2>, _Comp, _Proj2>
 && indirect_strict_weak_order<_Comp,
          projected<iterator_t<_Range1>, _Proj1>,
          projected<iterator_t<_Range2>, _Proj2>>
      constexpr partial_sort_copy_result<borrowed_iterator_t<_Range1>,
      borrowed_iterator_t<_Range2>>
      operator()(_Range1&& __r, _Range2&& __out, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         ranges::begin(__out), ranges::end(__out),
         std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __partial_sort_copy_fn partial_sort_copy{};

  struct __is_sorted_until_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return __first;

 auto __next = __first;
 for (++__next; __next != __last; __first = __next, (void)++__next)
   if (std::__invoke(__comp,
       std::__invoke(__proj, *__next),
       std::__invoke(__proj, *__first)))
     return __next;
 return __next;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __is_sorted_until_fn is_sorted_until{};

  struct __is_sorted_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return true;

 auto __next = __first;
 for (++__next; __next != __last; __first = __next, (void)++__next)
   if (std::__invoke(__comp,
       std::__invoke(__proj, *__next),
       std::__invoke(__proj, *__first)))
     return false;
 return true;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __is_sorted_fn is_sorted{};

  struct __nth_element_fn
  {
    template<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr _Iter
      operator()(_Iter __first, _Iter __nth, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::nth_element(std::move(__first), std::move(__nth),
        __lasti,
        __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, iterator_t<_Range> __nth,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), std::move(__nth),
         ranges::end(__r), std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __nth_element_fn nth_element{};

  struct __lower_bound_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp ,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __len = ranges::distance(__first, __last);

 while (__len > 0)
   {
     auto __half = __len / 2;
     auto __middle = __first;
     ranges::advance(__middle, __half);
     if (std::__invoke(__comp, std::__invoke(__proj, *__middle), __value))
       {
  __first = __middle;
  ++__first;
  __len = __len - __half - 1;
       }
     else
       __len = __half;
   }
 return __first;
      }

    template<forward_range _Range,
      typename _Proj = identity,
      typename _Tp
                                                                  ,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __lower_bound_fn lower_bound{};

  struct __upper_bound_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp ,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __len = ranges::distance(__first, __last);

 while (__len > 0)
   {
     auto __half = __len / 2;
     auto __middle = __first;
     ranges::advance(__middle, __half);
     if (std::__invoke(__comp, __value, std::__invoke(__proj, *__middle)))
       __len = __half;
     else
       {
  __first = __middle;
  ++__first;
  __len = __len - __half - 1;
       }
   }
 return __first;
      }

    template<forward_range _Range,
      typename _Proj = identity,
      typename _Tp
                                                                  ,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __upper_bound_fn upper_bound{};

  struct __equal_range_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp ,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __len = ranges::distance(__first, __last);

 while (__len > 0)
   {
     auto __half = __len / 2;
     auto __middle = __first;
     ranges::advance(__middle, __half);
     if (std::__invoke(__comp,
         std::__invoke(__proj, *__middle),
         __value))
       {
  __first = __middle;
  ++__first;
  __len = __len - __half - 1;
       }
     else if (std::__invoke(__comp,
       __value,
       std::__invoke(__proj, *__middle)))
       __len = __half;
     else
       {
  auto __left
    = ranges::lower_bound(__first, __middle,
     __value, __comp, __proj);
  ranges::advance(__first, __len);
  auto __right
    = ranges::upper_bound(++__middle, __first,
     __value, __comp, __proj);
  return {__left, __right};
       }
   }
 return {__first, __first};
      }

    template<forward_range _Range,
      typename _Proj = identity,
      typename _Tp
                                                                  ,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, const _Tp& __value,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __equal_range_fn equal_range{};

  struct __binary_search_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      typename _Tp ,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __i = ranges::lower_bound(__first, __last, __value, __comp, __proj);
 if (__i == __last)
   return false;
 return !(bool)std::__invoke(__comp, __value,
        std::__invoke(__proj, *__i));
      }

    template<forward_range _Range,
      typename _Proj = identity,
      typename _Tp
                                                                  ,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Range&& __r, const _Tp& __value, _Comp __comp = {},
   _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __binary_search_fn binary_search{};

  struct __is_partitioned_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr bool
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 __first = ranges::find_if_not(std::move(__first), __last,
          __pred, __proj);
 if (__first == __last)
   return true;
 ++__first;
 return ranges::none_of(std::move(__first), std::move(__last),
          std::move(__pred), std::move(__proj));
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr bool
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __is_partitioned_fn is_partitioned{};

  struct __partition_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 if constexpr (bidirectional_iterator<_Iter>)
   {
     auto __lasti = ranges::next(__first, __last);
     auto __tail = __lasti;
     for (;;)
       {
  for (;;)
    if (__first == __tail)
      return {std::move(__first), std::move(__lasti)};
    else if (std::__invoke(__pred,
      std::__invoke(__proj, *__first)))
      ++__first;
    else
      break;
  --__tail;
  for (;;)
    if (__first == __tail)
      return {std::move(__first), std::move(__lasti)};
    else if (!(bool)std::__invoke(__pred,
      std::__invoke(__proj, *__tail)))
      --__tail;
    else
      break;
  ranges::iter_swap(__first, __tail);
  ++__first;
       }
   }
 else
   {
     if (__first == __last)
       return {__first, __first};

     while (std::__invoke(__pred, std::__invoke(__proj, *__first)))
       if (++__first == __last)
  return {__first, __first};

     auto __next = __first;
     while (++__next != __last)
       if (std::__invoke(__pred, std::__invoke(__proj, *__next)))
  {
    ranges::iter_swap(__first, __next);
    ++__first;
  }

     return {std::move(__first), std::move(__next)};
   }
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_subrange_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __partition_fn partition{};


  struct __stable_partition_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires permutable<_Iter>

      subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 auto __middle
   = std::stable_partition(std::move(__first), __lasti,
      __detail::__make_pred_proj(__pred, __proj));
 return {std::move(__middle), std::move(__lasti)};
      }

    template<bidirectional_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>

      borrowed_subrange_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __stable_partition_fn stable_partition{};


  template<typename _Iter, typename _Out1, typename _Out2>
    struct in_out_out_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Out1 out1;
      [[no_unique_address]] _Out2 out2;

      template<typename _IIter, typename _OOut1, typename _OOut2>
 requires convertible_to<const _Iter&, _IIter>
   && convertible_to<const _Out1&, _OOut1>
   && convertible_to<const _Out2&, _OOut2>
 constexpr
 operator in_out_out_result<_IIter, _OOut1, _OOut2>() const &
 { return {in, out1, out2}; }

      template<typename _IIter, typename _OOut1, typename _OOut2>
 requires convertible_to<_Iter, _IIter>
   && convertible_to<_Out1, _OOut1>
   && convertible_to<_Out2, _OOut2>
 constexpr
 operator in_out_out_result<_IIter, _OOut1, _OOut2>() &&
 { return {std::move(in), std::move(out1), std::move(out2)}; }
    };

  template<typename _Iter, typename _Out1, typename _Out2>
    using partition_copy_result = in_out_out_result<_Iter, _Out1, _Out2>;

  struct __partition_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out1, weakly_incrementable _Out2,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_copyable<_Iter, _Out1>
 && indirectly_copyable<_Iter, _Out2>
      constexpr partition_copy_result<_Iter, _Out1, _Out2>
      operator()(_Iter __first, _Sent __last,
   _Out1 __out_true, _Out2 __out_false,
   _Pred __pred, _Proj __proj = {}) const
      {
 for (; __first != __last; ++__first)
   if (std::__invoke(__pred, std::__invoke(__proj, *__first)))
     {
       *__out_true = *__first;
       ++__out_true;
     }
   else
     {
       *__out_false = *__first;
       ++__out_false;
     }

 return {std::move(__first),
  std::move(__out_true), std::move(__out_false)};
      }

    template<input_range _Range, weakly_incrementable _Out1,
      weakly_incrementable _Out2,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out1>
 && indirectly_copyable<iterator_t<_Range>, _Out2>
      constexpr partition_copy_result<borrowed_iterator_t<_Range>, _Out1, _Out2>
      operator()(_Range&& __r, _Out1 __out_true, _Out2 __out_false,
   _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__out_true), std::move(__out_false),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __partition_copy_fn partition_copy{};

  struct __partition_point_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 auto __len = ranges::distance(__first, __last);

 while (__len > 0)
   {
     auto __half = __len / 2;
     auto __middle = __first;
     ranges::advance(__middle, __half);
     if (std::__invoke(__pred, std::__invoke(__proj, *__middle)))
       {
  __first = __middle;
  ++__first;
  __len = __len - __half - 1;
       }
     else
       __len = __half;
   }
 return __first;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __partition_point_fn partition_point{};

  template<typename _Iter1, typename _Iter2, typename _Out>
    using merge_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __merge_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2>
      constexpr merge_result<_Iter1, _Iter2, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   {
     if (std::__invoke(__comp,
         std::__invoke(__proj2, *__first2),
         std::__invoke(__proj1, *__first1)))
       {
  *__result = *__first2;
  ++__first2;
       }
     else
       {
  *__result = *__first1;
  ++__first1;
       }
     ++__result;
   }
 auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1),
        std::move(__result));
 auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2),
        std::move(__copy1.out));
 return { std::move(__copy1.in), std::move(__copy2.in),
   std::move(__copy2.out) };
      }

    template<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr merge_result<borrowed_iterator_t<_Range1>,
        borrowed_iterator_t<_Range2>,
        _Out>
      operator()(_Range1&& __r1, _Range2&& __r2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __merge_fn merge{};

  struct __inplace_merge_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less,
      typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>

      _Iter
      operator()(_Iter __first, _Iter __middle, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __lasti = ranges::next(__first, __last);
 std::inplace_merge(std::move(__first), std::move(__middle), __lasti,
      __detail::__make_comp_proj(__comp, __proj));
 return __lasti;
      }

    template<bidirectional_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>

      borrowed_iterator_t<_Range>
      operator()(_Range&& __r, iterator_t<_Range> __middle,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), std::move(__middle),
         ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __inplace_merge_fn inplace_merge{};

  struct __includes_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<_Iter1, _Proj1>,
     projected<_Iter2, _Proj2>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   if (std::__invoke(__comp,
       std::__invoke(__proj2, *__first2),
       std::__invoke(__proj1, *__first1)))
     return false;
   else if (std::__invoke(__comp,
     std::__invoke(__proj1, *__first1),
     std::__invoke(__proj2, *__first2)))
     ++__first1;
   else
     {
       ++__first1;
       ++__first2;
     }

 return __first2 == __last2;
      }

    template<input_range _Range1, input_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>,
     projected<iterator_t<_Range2>, _Proj2>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Range1&& __r1, _Range2&& __r2, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __includes_fn includes{};

  template<typename _Iter1, typename _Iter2, typename _Out>
    using set_union_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_union_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2>
      constexpr set_union_result<_Iter1, _Iter2, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2,
   _Out __result, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   {
     if (std::__invoke(__comp,
         std::__invoke(__proj1, *__first1),
         std::__invoke(__proj2, *__first2)))
       {
  *__result = *__first1;
  ++__first1;
       }
     else if (std::__invoke(__comp,
       std::__invoke(__proj2, *__first2),
       std::__invoke(__proj1, *__first1)))
       {
  *__result = *__first2;
  ++__first2;
       }
     else
       {
  *__result = *__first1;
  ++__first1;
  ++__first2;
       }
     ++__result;
   }
 auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1),
        std::move(__result));
 auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2),
        std::move(__copy1.out));
 return {std::move(__copy1.in), std::move(__copy2.in),
  std::move(__copy2.out)};
      }

    template<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_union_result<borrowed_iterator_t<_Range1>,
     borrowed_iterator_t<_Range2>, _Out>
      operator()(_Range1&& __r1, _Range2&& __r2,
   _Out __result, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __set_union_fn set_union{};

  template<typename _Iter1, typename _Iter2, typename _Out>
    using set_intersection_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_intersection_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2>
      constexpr set_intersection_result<_Iter1, _Iter2, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   if (std::__invoke(__comp,
       std::__invoke(__proj1, *__first1),
       std::__invoke(__proj2, *__first2)))
     ++__first1;
   else if (std::__invoke(__comp,
     std::__invoke(__proj2, *__first2),
     std::__invoke(__proj1, *__first1)))
     ++__first2;
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
       ++__result;
     }

 auto __last1i = ranges::next(std::move(__first1), std::move(__last1));
 auto __last2i = ranges::next(std::move(__first2), std::move(__last2));
 return {std::move(__last1i), std::move(__last2i), std::move(__result)};
      }

    template<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_intersection_result<borrowed_iterator_t<_Range1>,
     borrowed_iterator_t<_Range2>, _Out>
      operator()(_Range1&& __r1, _Range2&& __r2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __set_intersection_fn set_intersection{};

  template<typename _Iter, typename _Out>
    using set_difference_result = in_out_result<_Iter, _Out>;

  struct __set_difference_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2>
      constexpr set_difference_result<_Iter1, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   if (std::__invoke(__comp,
       std::__invoke(__proj1, *__first1),
       std::__invoke(__proj2, *__first2)))
     {
       *__result = *__first1;
       ++__first1;
       ++__result;
     }
   else if (std::__invoke(__comp,
     std::__invoke(__proj2, *__first2),
     std::__invoke(__proj1, *__first1)))
     ++__first2;
   else
     {
       ++__first1;
       ++__first2;
     }
 return ranges::copy(std::move(__first1), std::move(__last1),
       std::move(__result));
      }

    template<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_difference_result<borrowed_iterator_t<_Range1>, _Out>
      operator()(_Range1&& __r1, _Range2&& __r2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __set_difference_fn set_difference{};

  template<typename _Iter1, typename _Iter2, typename _Out>
    using set_symmetric_difference_result
      = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_symmetric_difference_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      weakly_incrementable _Out, typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2>
      constexpr set_symmetric_difference_result<_Iter1, _Iter2, _Out>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2,
   _Out __result, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2)
   if (std::__invoke(__comp,
       std::__invoke(__proj1, *__first1),
       std::__invoke(__proj2, *__first2)))
     {
       *__result = *__first1;
       ++__first1;
       ++__result;
     }
   else if (std::__invoke(__comp,
     std::__invoke(__proj2, *__first2),
     std::__invoke(__proj1, *__first1)))
     {
       *__result = *__first2;
       ++__first2;
       ++__result;
     }
   else
     {
       ++__first1;
       ++__first2;
     }
 auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1),
        std::move(__result));
 auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2),
        std::move(__copy1.out));
 return {std::move(__copy1.in), std::move(__copy2.in),
  std::move(__copy2.out)};
      }

    template<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_symmetric_difference_result<borrowed_iterator_t<_Range1>,
      borrowed_iterator_t<_Range2>,
      _Out>
      operator()(_Range1&& __r1, _Range2&& __r2, _Out __result,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__result), std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __set_symmetric_difference_fn set_symmetric_difference{};



  struct __max_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __a),
     std::__invoke(__proj, __b)))
   return __b;
 else
   return __a;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>,
         range_value_t<_Range>*>
      constexpr range_value_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false);
 auto __result = *__first;
 while (++__first != __last)
   {
     auto&& __tmp = *__first;
     if (std::__invoke(__comp,
         std::__invoke(__proj, __result),
         std::__invoke(__proj, __tmp)))
       __result = std::forward<decltype(__tmp)>(__tmp);
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr _Tp
      operator()(initializer_list<_Tp> __r,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::subrange(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __max_fn max{};

  struct __clamp_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp
        = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __val, const _Tp& __lo, const _Tp& __hi,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 do { if (std::__is_constant_evaluated() && !bool(!(std::__invoke(__comp, std::__invoke(__proj, __hi), std::__invoke(__proj, __lo))))) std::__glibcxx_assert_fail(); } while (false);


 auto&& __proj_val = std::__invoke(__proj, __val);
 if (std::__invoke(__comp,
     std::forward<decltype(__proj_val)>(__proj_val),
     std::__invoke(__proj, __lo)))
   return __lo;
 else if (std::__invoke(__comp,
          std::__invoke(__proj, __hi),
          std::forward<decltype(__proj_val)>(__proj_val)))
   return __hi;
 else
   return __val;
      }
  };

  inline constexpr __clamp_fn clamp{};

  template<typename _Tp>
    struct min_max_result
    {
      [[no_unique_address]] _Tp min;
      [[no_unique_address]] _Tp max;

      template<typename _Tp2>
 requires convertible_to<const _Tp&, _Tp2>
 constexpr
 operator min_max_result<_Tp2>() const &
 { return {min, max}; }

      template<typename _Tp2>
 requires convertible_to<_Tp, _Tp2>
 constexpr
 operator min_max_result<_Tp2>() &&
 { return {std::move(min), std::move(max)}; }
    };

  template<typename _Tp>
    using minmax_result = min_max_result<_Tp>;

  struct __minmax_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_result<const _Tp&>
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __b),
     std::__invoke(__proj, __a)))
   return {__b, __a};
 else
   return {__a, __b};
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>, range_value_t<_Range>*>
      constexpr minmax_result<range_value_t<_Range>>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated() && !bool(__first != __last)) std::__glibcxx_assert_fail(); } while (false);
 auto __comp_proj = __detail::__make_comp_proj(__comp, __proj);
 minmax_result<range_value_t<_Range>> __result = {*__first, __result.min};
 if (++__first == __last)
   return __result;
 else
   {


     auto&& __val = *__first;
     if (__comp_proj(__val, __result.min))
       __result.min = std::forward<decltype(__val)>(__val);
     else
       __result.max = std::forward<decltype(__val)>(__val);
   }
 while (++__first != __last)
   {



     range_value_t<_Range> __val1 = *__first;
     if (++__first == __last)
       {



  if (__comp_proj(__val1, __result.min))
    __result.min = std::move(__val1);
  else if (!__comp_proj(__val1, __result.max))
    __result.max = std::move(__val1);
  break;
       }
     auto&& __val2 = *__first;
     if (!__comp_proj(__val2, __val1))
       {
  if (__comp_proj(__val1, __result.min))
    __result.min = std::move(__val1);
  if (!__comp_proj(__val2, __result.max))
    __result.max = std::forward<decltype(__val2)>(__val2);
       }
     else
       {
  if (__comp_proj(__val2, __result.min))
    __result.min = std::forward<decltype(__val2)>(__val2);
  if (!__comp_proj(__val1, __result.max))
    __result.max = std::move(__val1);
       }
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_result<_Tp>
      operator()(initializer_list<_Tp> __r,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::subrange(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __minmax_fn minmax{};

  struct __min_element_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return __first;

 auto __i = __first;
 while (++__i != __last)
   {
     if (std::__invoke(__comp,
         std::__invoke(__proj, *__i),
         std::__invoke(__proj, *__first)))
       __first = __i;
   }
 return __first;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __min_element_fn min_element{};

  struct __max_element_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return __first;

 auto __i = __first;
 while (++__i != __last)
   {
     if (std::__invoke(__comp,
         std::__invoke(__proj, *__first),
         std::__invoke(__proj, *__i)))
       __first = __i;
   }
 return __first;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __max_element_fn max_element{};

  template<typename _Iter>
    using minmax_element_result = min_max_result<_Iter>;

  struct __minmax_element_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_element_result<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __comp_proj = __detail::__make_comp_proj(__comp, __proj);
 minmax_element_result<_Iter> __result = {__first, __first};
 if (__first == __last || ++__first == __last)
   return __result;
 else
   {


     if (__comp_proj(*__first, *__result.min))
       __result.min = __first;
     else
       __result.max = __first;
   }
 while (++__first != __last)
   {



     auto __prev = __first;
     if (++__first == __last)
       {



  if (__comp_proj(*__prev, *__result.min))
    __result.min = __prev;
  else if (!__comp_proj(*__prev, *__result.max))
    __result.max = __prev;
  break;
       }
     if (!__comp_proj(*__first, *__prev))
       {
  if (__comp_proj(*__prev, *__result.min))
    __result.min = __prev;
  if (!__comp_proj(*__first, *__result.max))
    __result.max = __first;
       }
     else
       {
  if (__comp_proj(*__first, *__result.min))
    __result.min = __first;
  if (!__comp_proj(*__prev, *__result.max))
    __result.max = __prev;
       }
   }
 return __result;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_element_result<borrowed_iterator_t<_Range>>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __minmax_element_fn minmax_element{};

  struct __lexicographical_compare_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<_Iter1, _Proj1>,
     projected<_Iter2, _Proj2>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2,
   _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if constexpr (__detail::__is_normal_iterator<_Iter1>
        && same_as<_Iter1, _Sent1>)
   return (*this)(__first1.base(), __last1.base(),
    std::move(__first2), std::move(__last2),
    std::move(__comp),
    std::move(__proj1), std::move(__proj2));
 else if constexpr (__detail::__is_normal_iterator<_Iter2>
      && same_as<_Iter2, _Sent2>)
   return (*this)(std::move(__first1), std::move(__last1),
    __first2.base(), __last2.base(),
    std::move(__comp),
    std::move(__proj1), std::move(__proj2));
 else
   {
     constexpr bool __sized_iters
       = (sized_sentinel_for<_Sent1, _Iter1>
   && sized_sentinel_for<_Sent2, _Iter2>);
     if constexpr (__sized_iters)
       {
  using _ValueType1 = iter_value_t<_Iter1>;
  using _ValueType2 = iter_value_t<_Iter2>;


  constexpr bool __use_memcmp
    = (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value
       && __ptr_to_nonvolatile<_Iter1>
       && __ptr_to_nonvolatile<_Iter2>
       && (is_same_v<_Comp, ranges::less>
    || is_same_v<_Comp, ranges::greater>)
       && is_same_v<_Proj1, identity>
       && is_same_v<_Proj2, identity>);
  if constexpr (__use_memcmp)
    {
      const auto __d1 = __last1 - __first1;
      const auto __d2 = __last2 - __first2;

      if (const auto __len = std::min(__d1, __d2))
        {
   const auto __c
     = std::__memcmp(__first1, __first2, __len);
   if constexpr (is_same_v<_Comp, ranges::less>)
     {
       if (__c < 0)
         return true;
       if (__c > 0)
         return false;
     }
   else if constexpr (is_same_v<_Comp, ranges::greater>)
     {
       if (__c > 0)
         return true;
       if (__c < 0)
         return false;
     }
        }
      return __d1 < __d2;
    }
       }

     for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void) ++__first2)
       {
  if (std::__invoke(__comp,
      std::__invoke(__proj1, *__first1),
      std::__invoke(__proj2, *__first2)))
    return true;
  if (std::__invoke(__comp,
      std::__invoke(__proj2, *__first2),
      std::__invoke(__proj1, *__first1)))
    return false;
       }
     return __first1 == __last1 && __first2 != __last2;
   }
      }

    template<input_range _Range1, input_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>,
     projected<iterator_t<_Range2>, _Proj2>>
        _Comp = ranges::less>
      constexpr bool
      operator()(_Range1&& __r1, _Range2&& __r2, _Comp __comp = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__comp),
         std::move(__proj1), std::move(__proj2));
      }

  private:
    template<typename _Iter, typename _Ref = iter_reference_t<_Iter>>
      static constexpr bool __ptr_to_nonvolatile
 = is_pointer_v<_Iter> && !is_volatile_v<remove_reference_t<_Ref>>;
  };

  inline constexpr __lexicographical_compare_fn lexicographical_compare;

  template<typename _Iter>
    struct in_found_result
    {
      [[no_unique_address]] _Iter in;
      bool found;

      template<typename _Iter2>
 requires convertible_to<const _Iter&, _Iter2>
 constexpr
 operator in_found_result<_Iter2>() const &
 { return {in, found}; }

      template<typename _Iter2>
 requires convertible_to<_Iter, _Iter2>
 constexpr
 operator in_found_result<_Iter2>() &&
 { return {std::move(in), found}; }
    };

  template<typename _Iter>
    using next_permutation_result = in_found_result<_Iter>;

  struct __next_permutation_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr next_permutation_result<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return {std::move(__first), false};

 auto __i = __first;
 ++__i;
 if (__i == __last)
   return {std::move(__i), false};

 auto __lasti = ranges::next(__first, __last);
 __i = __lasti;
 --__i;

 for (;;)
   {
     auto __ii = __i;
     --__i;
     if (std::__invoke(__comp,
         std::__invoke(__proj, *__i),
         std::__invoke(__proj, *__ii)))
       {
  auto __j = __lasti;
  while (!(bool)std::__invoke(__comp,
         std::__invoke(__proj, *__i),
         std::__invoke(__proj, *--__j)))
    ;
  ranges::iter_swap(__i, __j);
  ranges::reverse(__ii, __last);
  return {std::move(__lasti), true};
       }
     if (__i == __first)
       {
  ranges::reverse(__first, __last);
  return {std::move(__lasti), false};
       }
   }
      }

    template<bidirectional_range _Range, typename _Comp = ranges::less,
      typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr next_permutation_result<borrowed_iterator_t<_Range>>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __next_permutation_fn next_permutation{};

  template<typename _Iter>
    using prev_permutation_result = in_found_result<_Iter>;

  struct __prev_permutation_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<_Iter, _Comp, _Proj>
      constexpr prev_permutation_result<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return {std::move(__first), false};

 auto __i = __first;
 ++__i;
 if (__i == __last)
   return {std::move(__i), false};

 auto __lasti = ranges::next(__first, __last);
 __i = __lasti;
 --__i;

 for (;;)
   {
     auto __ii = __i;
     --__i;
     if (std::__invoke(__comp,
         std::__invoke(__proj, *__ii),
         std::__invoke(__proj, *__i)))
       {
  auto __j = __lasti;
  while (!(bool)std::__invoke(__comp,
         std::__invoke(__proj, *--__j),
         std::__invoke(__proj, *__i)))
    ;
  ranges::iter_swap(__i, __j);
  ranges::reverse(__ii, __last);
  return {std::move(__lasti), true};
       }
     if (__i == __first)
       {
  ranges::reverse(__first, __last);
  return {std::move(__lasti), false};
       }
   }
      }

    template<bidirectional_range _Range, typename _Comp = ranges::less,
      typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr prev_permutation_result<borrowed_iterator_t<_Range>>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __prev_permutation_fn prev_permutation{};
# 3979 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algo.h" 3
}

  template<typename _ForwardIterator>
    constexpr _ForwardIterator
    shift_left(_ForwardIterator __first, _ForwardIterator __last,
        typename iterator_traits<_ForwardIterator>::difference_type __n)
    {
      do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
      if (__n == 0)
 return __last;

      auto __mid = ranges::next(__first, __n, __last);
      if (__mid == __last)
 return __first;
      return std::move(std::move(__mid), std::move(__last), std::move(__first));
    }

  template<typename _ForwardIterator>
    constexpr _ForwardIterator
    shift_right(_ForwardIterator __first, _ForwardIterator __last,
  typename iterator_traits<_ForwardIterator>::difference_type __n)
    {
      do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) std::__glibcxx_assert_fail(); } while (false);
      if (__n == 0)
 return __first;

      using _Cat
 = typename iterator_traits<_ForwardIterator>::iterator_category;
      if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
 {
   auto __mid = ranges::next(__last, -__n, __first);
   if (__mid == __first)
     return __last;

   return std::move_backward(std::move(__first), std::move(__mid),
        std::move(__last));
 }
      else
 {
   auto __result = ranges::next(__first, __n, __last);
   if (__result == __last)
     return __last;

   auto __dest_head = __first, __dest_tail = __result;
   while (__dest_head != __result)
     {
       if (__dest_tail == __last)
  {





    std::move(std::move(__first), std::move(__dest_head), __result);
    return __result;
  }
       ++__dest_head;
       ++__dest_tail;
     }

   for (;;)
     {
# 4049 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/ranges_algo.h" 3
       auto __cursor = __first;
       while (__cursor != __result)
  {
    if (__dest_tail == __last)
      {



        __dest_head = std::move(__cursor, __result,
           std::move(__dest_head));
        std::move(std::move(__first), std::move(__cursor),
    std::move(__dest_head));
        return __result;
      }
    std::iter_swap(__cursor, __dest_head);
    ++__dest_head;
    ++__dest_tail;
    ++__cursor;
  }
     }
 }
    }


}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 2 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 2 3








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/glue_algorithm_defs.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/pstl/glue_algorithm_defs.h" 3
namespace std
{



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
                                                 typename iterator_traits<_ForwardIterator>::difference_type>
count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
                                                 typename iterator_traits<_ForwardIterator>::difference_type>
count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp , class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp& __value, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);

template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result,
        _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
            _ForwardIterator2 __first2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
          _UnaryOperation __op);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator __result, _BinaryOperation __op);



template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
           const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
        const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
             const _Tp& __old_value, const _Tp& __new_value);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value);


template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp >
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);



template <class _ExecutionPolicy, class _BidirectionalIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
             _ForwardIterator __d_first);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
            _ForwardIterator2 __result);



template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                 _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
          class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
               _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _BinaryPredicate __p);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _BinaryPredicate __p);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2);


template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last);


template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last);


template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _BidirectionalIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result,
                         _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);


template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);

template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2);

}
# 90 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/algorithm" 2 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3







#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 );
# 188 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 3
inline void sp_enable_shared_from_this( ... )
{
}





template< class Y, class T > inline void sp_assert_convertible() noexcept
{
    static_assert( sp_convertible< Y, T >::value, "incompatible pointer type" );
}



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
{
};

}
# 253 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 3
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( std::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, static_cast< D&& >( d ) )
    {
        boost::detail::sp_deleter_construct( this, p );
    }

    template<class D> shared_ptr( std::nullptr_t p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
    {
    }



    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
    {
        boost::detail::sp_deleter_construct( this, p );
    }

    template<class D, class A> shared_ptr( std::nullptr_t p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
    {
    }




    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 );
    }



    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;
    }



    template<class Y, class D>
    shared_ptr & operator=( std::unique_ptr<Y, D> && r )
    {
        this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
        return *this;
    }

    template<class Y, class D>
    shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
    {


        boost::detail::sp_assert_convertible< Y, T >();

        typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();

        shared_ptr tmp;

        if( p != 0 )
        {
            tmp.px = p;
            tmp.pn = boost::detail::shared_count( r );

            boost::detail::sp_deleter_construct( &tmp, p );
        }

        tmp.swap( *this );

        return *this;
    }



    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
    {
        r.px = 0;
    }

    template<class Y>
    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
    noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
    {
        boost::detail::sp_assert_convertible< Y, T >();
        r.px = 0;
    }

    shared_ptr & operator=( shared_ptr && r ) noexcept
    {
        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
        return *this;
    }

    template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }


    template<class Y>
    shared_ptr( shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn()
    {
        pn.swap( r.pn );
        r.px = 0;
    }

    shared_ptr & operator=( std::nullptr_t ) noexcept
    {
        this_type().swap(*this);
        return *this;
    }

    void reset() noexcept
    {
        this_type().swap(*this);
    }

    template<class Y> void reset( Y * p )
    {
        (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 518, __extension__ __PRETTY_FUNCTION__));
        this_type( p ).swap( *this );
    }

    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, static_cast< D&& >( d ) ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, static_cast< D&& >( d ), a ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) noexcept
    {
        this_type( r, p ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
    }

    typename boost::detail::sp_dereference< T >::type operator* () const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 544, __extension__ __PRETTY_FUNCTION__));
        return *px;
    }

    typename boost::detail::sp_member_access< T >::type operator-> () const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 550, __extension__ __PRETTY_FUNCTION__));
        return px;
    }

    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 556, __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> (i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )) ? void (0) : __assert_fail ("i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 557, __extension__ __PRETTY_FUNCTION__));

        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
    }

    element_type * get() const noexcept
    {
        return px;
    }

    explicit operator bool () const noexcept
    {
        return px != 0;
    }

    bool unique() const noexcept
    {
        return pn.unique();
    }

    long use_count() const noexcept
    {
        return pn.use_count();
    }

    void swap( shared_ptr & other ) noexcept
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    std::size_t owner_hash_value() const noexcept
    {
        return pn.hash_value();
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
    {
        return pn.get_deleter( ti );
    }

    void * _internal_get_local_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
    {
        return pn.get_local_deleter( ti );
    }

    void * _internal_get_untyped_deleter() const noexcept
    {
        return pn.get_untyped_deleter();
    }

    bool _internal_equiv( shared_ptr const & r ) const noexcept
    {
        return px == r.px && pn == r.pn;
    }

    boost::detail::shared_count _internal_count() const noexcept
    {
        return pn;
    }

private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;


    element_type * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() != b.get();
}

template<class T> inline bool operator==( shared_ptr<T> const & p, std::nullptr_t ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator==( std::nullptr_t, shared_ptr<T> const & p ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator!=( shared_ptr<T> const & p, std::nullptr_t ) noexcept
{
    return p.get() != 0;
}

template<class T> inline bool operator!=( std::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();
}



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;
}



namespace detail
{

template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}

template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept;
template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept;

class esft2_deleter_wrapper
{
private:

    shared_ptr<void const volatile> deleter_;

public:

    esft2_deleter_wrapper() noexcept
    {
    }

    template< class T > void set_deleter( shared_ptr<T> const & deleter ) noexcept
    {
        deleter_ = deleter;
    }

    template<typename D> D* get_deleter() const noexcept
    {
        return boost::detail::basic_get_deleter<D>( deleter_ );
    }

    template< class T> void operator()( T* ) noexcept
    {
        (static_cast <bool> (deleter_.use_count() <= 1) ? void (0) : __assert_fail ("deleter_.use_count() <= 1", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp", 821, __extension__ __PRETTY_FUNCTION__));
        deleter_.reset();
    }
};

}

template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
    D * d = boost::detail::basic_get_deleter<D>( p );

    if( d == 0 )
    {
        d = boost::detail::basic_get_local_deleter( d, p );
    }

    if( d == 0 )
    {
        boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);


        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
    }

    return d;
}





template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T, class M> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, M ) noexcept
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T, class M> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T, class M> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T, class M> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, M, M ) noexcept
{
    return atomic_compare_exchange( p, v, w );
}





template< class T > struct hash;

template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
    return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
}

}



namespace std
{

template<class T> struct hash< ::boost::shared_ptr<T> >
{
    std::size_t operator()( ::boost::shared_ptr<T> const & p ) const noexcept
    {
        return std::hash< typename ::boost::shared_ptr<T>::element_type* >()( p.get() );
    }
};

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/local_counted_base.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/local_counted_base.hpp" 3
namespace boost
{

namespace detail
{

class __attribute__((__visibility__("default"))) local_counted_base
{
private:

    local_counted_base & operator= ( local_counted_base const & );

private:


    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };

    count_type local_use_count_;

public:

    constexpr local_counted_base() noexcept: local_use_count_( initial_ )
    {
    }

    constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
    {
    }

    virtual ~local_counted_base()
    {
    }

    virtual void local_cb_destroy() noexcept = 0;

    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;

    void add_ref() noexcept
    {




        __builtin_assume( local_use_count_ >= 1 );





        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
    }

    void release() noexcept
    {
        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );

        if( local_use_count_ == 0 )
        {
            local_cb_destroy();
        }
    }

    long local_use_count() const noexcept
    {
        return local_use_count_;
    }
};

class __attribute__((__visibility__("default"))) local_counted_impl: public local_counted_base
{
private:

    local_counted_impl( local_counted_impl const & );

private:

    shared_count pn_;

public:

    explicit local_counted_impl( shared_count const& pn ) noexcept: pn_( pn )
    {
    }

    explicit local_counted_impl( shared_count && pn ) noexcept: pn_( std::move(pn) )
    {
    }

    void local_cb_destroy() noexcept override
    {
        delete this;
    }

    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
    {
        return pn_;
    }
};

class __attribute__((__visibility__("default"))) local_counted_impl_em: public local_counted_base
{
public:

    shared_count pn_;

    void local_cb_destroy() noexcept override
    {
        shared_count().swap( pn_ );
    }

    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
    {
        return pn_;
    }
};

}

}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 2 3


namespace boost
{

namespace detail
{

template<class D> class local_sp_deleter: public local_counted_impl_em
{
private:

    D d_;

public:

    local_sp_deleter(): d_()
    {
    }

    explicit local_sp_deleter( D const& d ) noexcept: d_( d )
    {
    }

    explicit local_sp_deleter( D&& d ) noexcept: d_( std::move(d) )
    {
    }

    D& deleter() noexcept
    {
        return d_;
    }

    template<class Y> void operator()( Y* p ) noexcept
    {
        d_( p );
    }

    void operator()( std::nullptr_t p ) noexcept
    {
        d_( p );
    }
};

template<> class local_sp_deleter<void>
{
};

template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept
{
    return &p->deleter();
}

inline void * get_local_deleter( local_sp_deleter<void> * ) noexcept
{
    return 0;
}

}

}
# 954 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/smart_ptr/shared_ptr.hpp" 2 3

namespace boost
{

namespace detail
{

template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

}



template<class T> shared_ptr( weak_ptr<T> ) -> shared_ptr<T>;
template<class T, class D> shared_ptr( std::unique_ptr<T, D> ) -> shared_ptr<T>;



}


#pragma GCC diagnostic pop
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/shared_ptr.hpp" 2 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 2 3

namespace boost {
    namespace io {

        template<class Ch, class Tr=::std::char_traits<Ch>,
                 class Alloc=::std::allocator<Ch> >
        class basic_altstringbuf;

        template<class Ch, class Tr =::std::char_traits<Ch>,
                 class Alloc=::std::allocator<Ch> >
        class basic_oaltstringstream;


        template<class Ch, class Tr, class Alloc>
        class basic_altstringbuf
            : public ::std::basic_streambuf<Ch, Tr>
        {
            typedef ::std::basic_streambuf<Ch, Tr> streambuf_t;
            typedef typename CompatAlloc<Alloc>::compatible_type compat_allocator_type;
            typedef typename CompatTraits<Tr>::compatible_type compat_traits_type;
        public:
            typedef Ch char_type;
            typedef Tr traits_type;
            typedef typename compat_traits_type::int_type int_type;
            typedef typename compat_traits_type::pos_type pos_type;
            typedef typename compat_traits_type::off_type off_type;
            typedef Alloc allocator_type;
            typedef ::std::basic_string<Ch, Tr, Alloc> string_type;
            typedef typename string_type::size_type size_type;

            typedef ::std::streamsize streamsize;


            explicit basic_altstringbuf(std::ios_base::openmode mode
                                        = std::ios_base::in | std::ios_base::out)
                : putend_(__null), is_allocated_(false), mode_(mode)
                {}
            explicit basic_altstringbuf(const string_type& s,
                                        ::std::ios_base::openmode mode
                                        = ::std::ios_base::in | ::std::ios_base::out)
                : putend_(__null), is_allocated_(false), mode_(mode)
                { dealloc(); str(s); }
            virtual ~basic_altstringbuf() noexcept
                { dealloc(); }
            using streambuf_t::pbase;
            using streambuf_t::pptr;
            using streambuf_t::epptr;
            using streambuf_t::eback;
            using streambuf_t::gptr;
            using streambuf_t::egptr;

            void clear_buffer();
            void str(const string_type& s);


            Ch * begin() const;
            size_type size() const;
            size_type cur_size() const;
            Ch * pend() const
                { return ((putend_ < pptr()) ? pptr() : putend_); }
            size_type pcount() const
                { return static_cast<size_type>( pptr() - pbase()) ;}


            string_type str() const
                { return string_type(begin(), size()); }
            string_type cur_str() const
                { return string_type(begin(), cur_size()); }
        protected:
            explicit basic_altstringbuf (basic_altstringbuf * s,
                                         ::std::ios_base::openmode mode
                                         = ::std::ios_base::in | ::std::ios_base::out)
                : putend_(__null), is_allocated_(false), mode_(mode)
                { dealloc(); str(s); }

            virtual pos_type seekoff(off_type off, ::std::ios_base::seekdir way,
                                     ::std::ios_base::openmode which
                                     = ::std::ios_base::in | ::std::ios_base::out);
            virtual pos_type seekpos (pos_type pos,
                                      ::std::ios_base::openmode which
                                      = ::std::ios_base::in | ::std::ios_base::out);
            virtual int_type underflow();
            virtual int_type pbackfail(int_type meta = compat_traits_type::eof());
            virtual int_type overflow(int_type meta = compat_traits_type::eof());
            void dealloc();
        private:
            enum { alloc_min = 256};

            Ch *putend_;
            bool is_allocated_;
            ::std::ios_base::openmode mode_;
            compat_allocator_type alloc_;
        };



        template <class Ch, class Tr, class Alloc>
        class basic_oaltstringstream
            : private base_from_member< shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >,
              public ::std::basic_ostream<Ch, Tr>
        {
            class No_Op {

            public:
                template<class T>
                const T & operator()(const T & arg) { return arg; }
            };
            typedef ::std::basic_ostream<Ch, Tr> stream_t;
            typedef boost::base_from_member<boost::shared_ptr<
                basic_altstringbuf<Ch,Tr, Alloc> > >
                pbase_type;
            typedef ::std::basic_string<Ch, Tr, Alloc> string_type;
            typedef typename string_type::size_type size_type;
            typedef basic_altstringbuf<Ch, Tr, Alloc> stringbuf_t;
        public:
            typedef Alloc allocator_type;
            basic_oaltstringstream()
                : pbase_type(new stringbuf_t), stream_t(pbase_type::member.get())
                { }
            basic_oaltstringstream(::boost::shared_ptr<stringbuf_t> buf)
                : pbase_type(buf), stream_t(pbase_type::member.get())
                { }
            basic_oaltstringstream(stringbuf_t * buf)
                : pbase_type(buf, No_Op() ), stream_t(pbase_type::member.get())
                { }
            stringbuf_t * rdbuf() const
                { return pbase_type::member.get(); }
            void clear_buffer()
                { rdbuf()->clear_buffer(); }


            Ch * begin() const
                { return rdbuf()->begin(); }
            size_type size() const
                { return rdbuf()->size(); }
            size_type cur_size() const
                { return rdbuf()->cur_size(); }


            string_type str() const
                { return rdbuf()->str(); }
            string_type cur_str() const
                { return rdbuf()->cur_str(); }
            void str(const string_type& s)
                { rdbuf()->str(s); }
        };

    }
}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream_impl.hpp" 1 3
# 16 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream_impl.hpp" 3
namespace boost {
    namespace io {


        template<class Ch, class Tr, class Alloc>
        void basic_altstringbuf<Ch, Tr, Alloc>::
        clear_buffer () {
            const Ch * p = pptr();
            const Ch * b = pbase();
            if(p != __null && p != b) {
                seekpos(0, ::std::ios_base::out);
            }
            p = gptr();
            b = eback();
            if(p != __null && p != b) {
                seekpos(0, ::std::ios_base::in);
            }
        }

        template<class Ch, class Tr, class Alloc>
        void basic_altstringbuf<Ch, Tr, Alloc>::
        str (const string_type& s) {
            size_type sz=s.size();
            if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) {




                Ch *new_ptr = boost::allocator_allocate(alloc_, sz, is_allocated_? eback() : 0);


                dealloc();
                sz = s.copy(new_ptr, sz);
                putend_ = new_ptr + sz;
                if(mode_ & ::std::ios_base::in)
                    streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz);
                if(mode_ & ::std::ios_base::out) {
                    streambuf_t::setp(new_ptr, new_ptr + sz);
                    if(mode_ & (::std::ios_base::app | ::std::ios_base::ate))
                        streambuf_t::pbump(static_cast<int>(sz));
                    if(gptr() == __null)
                        streambuf_t::setg(new_ptr, __null, new_ptr);
                }
                is_allocated_ = true;
            }
            else
                dealloc();
        }
        template<class Ch, class Tr, class Alloc>
        Ch* basic_altstringbuf<Ch, Tr, Alloc>::
        begin () const {
            if(mode_ & ::std::ios_base::out && pptr() != __null)
                return pbase();
            else if(mode_ & ::std::ios_base::in && gptr() != __null)
                return eback();
            return __null;
        }

        template<class Ch, class Tr, class Alloc>
        typename std::basic_string<Ch,Tr,Alloc>::size_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        size () const {
            if(mode_ & ::std::ios_base::out && pptr())
                return static_cast<size_type>(pend() - pbase());
            else if(mode_ & ::std::ios_base::in && gptr())
                return static_cast<size_type>(egptr() - eback());
            else
                return 0;
        }

        template<class Ch, class Tr, class Alloc>
        typename std::basic_string<Ch,Tr,Alloc>::size_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        cur_size () const {
            if(mode_ & ::std::ios_base::out && pptr())
                return static_cast<streamsize>( pptr() - pbase());
            else if(mode_ & ::std::ios_base::in && gptr())
                return static_cast<streamsize>( gptr() - eback());
            else
                return 0;
        }

        template<class Ch, class Tr, class Alloc>
        typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
            if(pptr() != __null && putend_ < pptr())
                putend_ = pptr();
            if(which & ::std::ios_base::in && gptr() != __null) {

                if(way == ::std::ios_base::end)
                    off += static_cast<off_type>(putend_ - gptr());
                else if(way == ::std::ios_base::beg)
                    off += static_cast<off_type>(eback() - gptr());
                else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) )

                    return pos_type(off_type(-1));
                if(eback() <= off+gptr() && off+gptr() <= putend_ ) {

                    streambuf_t::gbump(static_cast<int>(off));
                    if(which & ::std::ios_base::out && pptr() != __null)

                        streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
                }
                else
                    off = off_type(-1);
            }
            else if(which & ::std::ios_base::out && pptr() != __null) {

                if(way == ::std::ios_base::end)
                    off += static_cast<off_type>(putend_ - pptr());
                else if(way == ::std::ios_base::beg)
                    off += static_cast<off_type>(pbase() - pptr());
                else
                    return pos_type(off_type(-1));
                if(pbase() <= off+pptr() && off+pptr() <= putend_)

                    streambuf_t::pbump(static_cast<int>(off));
                else
                    off = off_type(-1);
            }
            else
                off = off_type(-1);
            return (pos_type(off));
        }



        template<class Ch, class Tr, class Alloc>
        typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        seekpos (pos_type pos, ::std::ios_base::openmode which) {
            off_type off = off_type(pos);
            if(pptr() != __null && putend_ < pptr())
                putend_ = pptr();
            if(off != off_type(-1)) {
                if(which & ::std::ios_base::in && gptr() != __null) {

                    if(0 <= off && off <= putend_ - eback()) {
                        streambuf_t::gbump(static_cast<int>(eback() - gptr() + off));
                        if(which & ::std::ios_base::out && pptr() != __null) {

                            streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
                        }
                    }
                    else
                        off = off_type(-1);
                }
                else if(which & ::std::ios_base::out && pptr() != __null) {

                    if(0 <= off && off <= putend_ - eback())
                        streambuf_t::pbump(static_cast<int>(eback() - pptr() + off));
                    else
                        off = off_type(-1);
                }
                else
                    off = off_type(-1);
                return (pos_type(off));
            }
            else {
                (static_cast <bool> (0) ? void (0) : __assert_fail ("0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream_impl.hpp", 176, __extension__ __PRETTY_FUNCTION__));
                return pos_type(off_type(-1));
            }
        }



        template<class Ch, class Tr, class Alloc>
        typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        underflow () {
            if(gptr() == __null)
                return (compat_traits_type::eof());
            else if(gptr() < egptr())
                return (compat_traits_type::to_int_type(*gptr()));
            else if(mode_ & ::std::ios_base::in && pptr() != __null
                    && (gptr() < pptr() || gptr() < putend_) )
                {
                    if(putend_ < pptr())
                        putend_ = pptr();
                    streambuf_t::setg(eback(), gptr(), putend_);
                    return (compat_traits_type::to_int_type(*gptr()));
                }
            else
                return (compat_traits_type::eof());
        }



        template<class Ch, class Tr, class Alloc>
        typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        pbackfail (int_type meta) {
            if(gptr() != __null && (eback() < gptr())
               && (mode_ & (::std::ios_base::out)
                   || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)
                   || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) {
                streambuf_t::gbump(-1);
                if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))

                    *gptr() = compat_traits_type::to_char_type(meta);
                return (compat_traits_type::not_eof(meta));
            }
            else
                return (compat_traits_type::eof());
        }



        template<class Ch, class Tr, class Alloc>
        typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
        basic_altstringbuf<Ch, Tr, Alloc>::
        overflow (int_type meta) {




            if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
                return compat_traits_type::not_eof(meta);
            else if(pptr() != __null && pptr() < epptr()) {
                streambuf_t::sputc(compat_traits_type::to_char_type(meta));
                return meta;
            }
            else if(! (mode_ & ::std::ios_base::out))

                return compat_traits_type::eof();
            else {
                std::size_t prev_size = pptr() == __null ? 0 : epptr() - eback();
                std::size_t new_size = prev_size;

                std::size_t add_size = new_size / 2;
                if(add_size < alloc_min)
                    add_size = alloc_min;
                Ch * newptr = __null, *oldptr = eback();


                while (0 < add_size && ((std::numeric_limits<std::size_t>::max)()
                                        - add_size < new_size) )
                    add_size /= 2;
                if(0 < add_size) {
                    new_size += add_size;




                    newptr = boost::allocator_allocate(alloc_, new_size, is_allocated_? oldptr : 0);

                }

                if(0 < prev_size)
                    compat_traits_type::copy(newptr, oldptr, prev_size);
                if(is_allocated_)
                    alloc_.deallocate(oldptr, prev_size);
                is_allocated_=true;

                if(prev_size == 0) {
                    putend_ = newptr;
                    streambuf_t::setp(newptr, newptr + new_size);
                    if(mode_ & ::std::ios_base::in)
                        streambuf_t::setg(newptr, newptr, newptr + 1);
                    else
                        streambuf_t::setg(newptr, 0, newptr);
                }
                else {
                    putend_ = putend_ - oldptr + newptr;
                    int pptr_count = static_cast<int>(pptr()-pbase());
                    int gptr_count = static_cast<int>(gptr()-eback());
                    streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size);
                    streambuf_t::pbump(pptr_count);
                    if(mode_ & ::std::ios_base::in)
                        streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1);
                    else
                        streambuf_t::setg(newptr, 0, newptr);
                }
                streambuf_t::sputc(compat_traits_type::to_char_type(meta));
                return meta;
            }



        }


        template<class Ch, class Tr, class Alloc>
        void basic_altstringbuf<Ch, Tr, Alloc>:: dealloc() {
            if(is_allocated_)
                alloc_.deallocate(eback(), (pptr() != __null ? epptr() : egptr()) - eback());
            is_allocated_ = false;
            streambuf_t::setg(0, 0, 0);
            streambuf_t::setp(0, 0);
            putend_ = __null;
        }

    }
}
# 176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/alt_sstream.hpp" 2 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp" 2 3

namespace boost {
namespace io {
namespace detail {





    template<class Ch, class Tr>
    struct stream_format_state
    {
        typedef ::std:: basic_ios<Ch, Tr> basic_ios;

        stream_format_state(Ch fill) { reset(fill); }


        void reset(Ch fill);
        void set_by_stream(const basic_ios& os);
        void apply_on(basic_ios & os,
                      boost::io::detail::locale_t * loc_default = 0) const;
        template<class T>
        void apply_manip(T manipulator)
            { apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }


        std::streamsize width_;
        std::streamsize precision_;
        Ch fill_;
        std::ios_base::fmtflags flags_;
        std::ios_base::iostate rdstate_;
        std::ios_base::iostate exceptions_;
        boost::optional<boost::io::detail::locale_t> loc_;
    };





    template<class Ch, class Tr, class Alloc>
    struct format_item
    {
        enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };



        enum arg_values { argN_no_posit = -1,
                          argN_tabulation = -2,
                          argN_ignored = -3
        };
        typedef ::std:: basic_ios<Ch, Tr> basic_ios;
        typedef detail::stream_format_state<Ch, Tr> stream_format_state;
        typedef ::std::basic_string<Ch, Tr, Alloc> string_type;

        format_item(Ch fill) :argN_(argN_no_posit), fmtstate_(fill),
                              truncate_(max_streamsize()), pad_scheme_(0) {}
        void reset(Ch fill);
        void compute_states();

        static std::streamsize max_streamsize() {
            return (std::numeric_limits<std::streamsize>::max)();
        }


        int argN_;

        string_type res_;
        string_type appendix_;

        stream_format_state fmtstate_;

        std::streamsize truncate_;
        unsigned int pad_scheme_;
    };






    template<class Ch, class Tr>
    void stream_format_state<Ch,Tr>:: apply_on (basic_ios & os,
                      boost::io::detail::locale_t * loc_default) const {


        if(loc_)
            os.imbue(loc_.get());
        else if(loc_default)
            os.imbue(*loc_default);




        if(width_ != -1)
            os.width(width_);
        if(precision_ != -1)
            os.precision(precision_);
        if(fill_ != 0)
            os.fill(fill_);
        os.flags(flags_);
        os.clear(rdstate_);
        os.exceptions(exceptions_);
    }

    template<class Ch, class Tr>
    void stream_format_state<Ch,Tr>:: set_by_stream(const basic_ios& os) {

        flags_ = os.flags();
        width_ = os.width();
        precision_ = os.precision();
        fill_ = os.fill();
        rdstate_ = os.rdstate();
        exceptions_ = os.exceptions();
    }


    template<class Ch, class Tr, class T>
    void apply_manip_body( stream_format_state<Ch, Tr>& self,
                           T manipulator) {

        basic_oaltstringstream<Ch, Tr> ss;
        self.apply_on( ss );
        ss << manipulator;
        self.set_by_stream( ss );
    }

    template<class Ch, class Tr> inline
    void stream_format_state<Ch,Tr>:: reset(Ch fill) {

        width_=0; precision_=6;
        fill_=fill;
        flags_ = std::ios_base::dec | std::ios_base::skipws;

        exceptions_ = std::ios_base::goodbit;
        rdstate_ = std::ios_base::goodbit;
    }




    template<class Ch, class Tr, class Alloc>
    void format_item<Ch, Tr, Alloc>::
    reset (Ch fill) {
        argN_=argN_no_posit; truncate_ = max_streamsize(); pad_scheme_ =0;
        res_.resize(0); appendix_.resize(0);
        fmtstate_.reset(fill);
    }

    template<class Ch, class Tr, class Alloc>
    void format_item<Ch, Tr, Alloc>::
    compute_states() {


        if(pad_scheme_ & zeropad) {

            if(fmtstate_.flags_ & std::ios_base::left) {
              (static_cast <bool> (!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left))) ? void (0) : __assert_fail ("!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left))", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/internals.hpp", 181, __extension__ __PRETTY_FUNCTION__));

              pad_scheme_ = pad_scheme_ & (~zeropad);
            }
            else {
                pad_scheme_ &= ~spacepad;
                fmtstate_.fill_='0';
                fmtstate_.flags_ = (fmtstate_.flags_ & ~std::ios_base::adjustfield)
                    | std::ios_base::internal;

            }
        }
        if(pad_scheme_ & spacepad) {
            if(fmtstate_.flags_ & std::ios_base::showpos)
                pad_scheme_ &= ~spacepad;
        }
    }


} } }
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_class.hpp" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_class.hpp" 3
namespace boost {

    template<class Ch, class Tr, class Alloc>
    class basic_format
    {
        typedef typename io::CompatTraits<Tr>::compatible_type compat_traits;
    public:
        typedef Ch CharT;
        typedef std::basic_string<Ch, Tr, Alloc> string_type;
        typedef typename string_type::size_type size_type;
        typedef io::detail::format_item<Ch, Tr, Alloc> format_item_t;
        typedef io::basic_altstringbuf<Ch, Tr, Alloc> internal_streambuf_t;


        explicit basic_format(const Ch* str=__null);
        explicit basic_format(const string_type& s);
        basic_format(const basic_format& x);
        basic_format& operator= (const basic_format& x);
        void swap(basic_format& x);


        explicit basic_format(const Ch* str, const std::locale & loc);
        explicit basic_format(const string_type& s, const std::locale & loc);

        io::detail::locale_t getloc() const;

        basic_format& clear();
        basic_format& clear_binds();
        basic_format& parse(const string_type&);


        size_type size() const;
        string_type str() const;


        template<class T>
        basic_format& operator%(const T& x)
            { return io::detail::feed<CharT, Tr, Alloc, const T&>(*this,x); }


        template<class T> basic_format& operator%(T& x)
            { return io::detail::feed<CharT, Tr, Alloc, T&>(*this,x); }


        template<class T>
        basic_format& operator%(volatile const T& x)
            { const T v(x);
                                             return io::detail::feed<CharT, Tr, Alloc, const T&>(*this, v); }


        template<class T>
        basic_format& operator%(volatile T& x)
            { T v(x);
                                             return io::detail::feed<CharT, Tr, Alloc, T&>(*this, v); }





        basic_format& operator%(const int& x)
            { return io::detail::feed<CharT, Tr, Alloc, const int&>(*this,x); }


        basic_format& operator%(int& x)
            { return io::detail::feed<CharT, Tr, Alloc, int&>(*this,x); }




        int expected_args() const
            { return num_args_; }

        int bound_args() const;

        int fed_args() const;

        int cur_arg() const;

        int remaining_args() const;



        template<class T>
        basic_format& bind_arg(int argN, const T& val)
            { return io::detail::bind_arg_body(*this, argN, val); }
        basic_format& clear_bind(int argN);
        template<class T>
        basic_format& modify_item(int itemN, T manipulator)
            { return io::detail::modify_item_body<Ch,Tr, Alloc, T> (*this, itemN, manipulator);}


        unsigned char exceptions() const;
        unsigned char exceptions(unsigned char newexcept);
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_class.hpp" 3
        template<class Ch2, class Tr2, class Alloc2>
        friend std::basic_ostream<Ch2, Tr2> &
        operator<<( std::basic_ostream<Ch2, Tr2> & ,
                    const basic_format<Ch2, Tr2, Alloc2>& );







        template<class Ch2, class Tr2, class Alloc2, class T>
        friend basic_format<Ch2, Tr2, Alloc2>&
        io::detail::feed_impl (basic_format<Ch2, Tr2, Alloc2>&, T);

        template<class Ch2, class Tr2, class Alloc2, class T> friend
        void io::detail::distribute (basic_format<Ch2, Tr2, Alloc2>&, T);

        template<class Ch2, class Tr2, class Alloc2, class T> friend
        basic_format<Ch2, Tr2, Alloc2>&
        io::detail::modify_item_body (basic_format<Ch2, Tr2, Alloc2>&, int, T);

        template<class Ch2, class Tr2, class Alloc2, class T> friend
        basic_format<Ch2, Tr2, Alloc2>&
        io::detail::bind_arg_body (basic_format<Ch2, Tr2, Alloc2>&, int, const T&);

    private:

        typedef io::detail::stream_format_state<Ch, Tr> stream_format_state;

        enum style_values { ordered = 1,
                             special_needs = 4 };

        void make_or_reuse_data(std::size_t nbitems);


        std::vector<format_item_t> items_;
        std::vector<bool> bound_;

        int style_;
        int cur_arg_;
        int num_args_;
        mutable bool dumped_;
        string_type prefix_;
        unsigned char exceptions_;
        internal_streambuf_t buf_;
        boost::optional<io::detail::locale_t> loc_;
    };

}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/exceptions.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/exceptions.hpp" 3
namespace boost {

    namespace io {



        class format_error : public std::exception
        {
        public:
            format_error() {}
            virtual const char *what() const noexcept override {
                return "boost::format_error: "
                    "format generic failure";
            }
        };

        class bad_format_string : public format_error
        {
            std::size_t pos_, next_;
        public:
            bad_format_string(std::size_t pos, std::size_t size)
                : pos_(pos), next_(size) {}
            std::size_t get_pos() const { return pos_; }
            std::size_t get_next() const { return next_; }
            virtual const char *what() const noexcept override {
                return "boost::bad_format_string: format-string is ill-formed";
            }
        };

        class too_few_args : public format_error
        {
            std::size_t cur_, expected_;
        public:
            too_few_args(std::size_t cur, std::size_t expected)
                : cur_(cur), expected_(expected) {}
            std::size_t get_cur() const { return cur_; }
            std::size_t get_expected() const { return expected_; }
            virtual const char *what() const noexcept override {
                return "boost::too_few_args: "
                    "format-string referred to more arguments than were passed";
            }
        };

        class too_many_args : public format_error
        {
            std::size_t cur_, expected_;
        public:
            too_many_args(std::size_t cur, std::size_t expected)
                : cur_(cur), expected_(expected) {}
            std::size_t get_cur() const { return cur_; }
            std::size_t get_expected() const { return expected_; }
            virtual const char *what() const noexcept override {
                return "boost::too_many_args: "
                    "format-string referred to fewer arguments than were passed";
            }
        };


        class out_of_range : public format_error
        {
            int index_, beg_, end_;
        public:
            out_of_range(int index, int beg, int end)
                : index_(index), beg_(beg), end_(end) {}
            int get_index() const { return index_; }
            int get_beg() const { return beg_; }
            int get_end() const { return end_; }
            virtual const char *what() const noexcept override {
                return "boost::out_of_range: "
                    "tried to refer to an argument (or item) number which"
                    " is out of range, according to the format string";
            }
        };


    }

}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp" 2 3



namespace boost {



    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s)
        : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
          exceptions_(io::all_error_bits)
    {
        if( s)
            parse( s );
    }


    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s, const std::locale & loc)
        : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
          exceptions_(io::all_error_bits), loc_(loc)
    {
        if(s) parse( s );
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s, const std::locale & loc)
        : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
          exceptions_(io::all_error_bits), loc_(loc)
    {
        parse(s);
    }

    template< class Ch, class Tr, class Alloc>
    io::detail::locale_t basic_format<Ch, Tr, Alloc>::
    getloc() const {
        return loc_ ? loc_.get() : io::detail::locale_t();
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s)
        : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
          exceptions_(io::all_error_bits)
    {
        parse(s);
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>:: basic_format(const basic_format& x)
        : items_(x.items_), bound_(x.bound_), style_(x.style_),
          cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(x.dumped_),
          prefix_(x.prefix_), exceptions_(x.exceptions_), loc_(x.loc_)
    {
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>& basic_format<Ch, Tr, Alloc>::
    operator= (const basic_format& x) {
        if(this == &x)
            return *this;
        (basic_format<Ch, Tr, Alloc>(x)).swap(*this);
        return *this;
    }
    template< class Ch, class Tr, class Alloc>
    void basic_format<Ch, Tr, Alloc>::
    swap (basic_format & x) {
        std::swap(exceptions_, x.exceptions_);
        std::swap(style_, x.style_);
        std::swap(cur_arg_, x.cur_arg_);
        std::swap(num_args_, x.num_args_);
        std::swap(dumped_, x.dumped_);

        items_.swap(x.items_);
        prefix_.swap(x.prefix_);
        bound_.swap(x.bound_);
    }

    template< class Ch, class Tr, class Alloc>
    unsigned char basic_format<Ch,Tr, Alloc>:: exceptions() const {
        return exceptions_;
    }

    template< class Ch, class Tr, class Alloc>
    unsigned char basic_format<Ch,Tr, Alloc>:: exceptions(unsigned char newexcept) {
        unsigned char swp = exceptions_;
        exceptions_ = newexcept;
        return swp;
    }

    template<class Ch, class Tr, class Alloc>
    void basic_format<Ch, Tr, Alloc>::
    make_or_reuse_data (std::size_t nbitems) {

        Ch fill = ( std::use_facet< std::ctype<Ch> >(getloc()) ). widen(' ');



        if(items_.size() == 0)
            items_.assign( nbitems, format_item_t(fill) );
        else {
            if(nbitems>items_.size())
                items_.resize(nbitems, format_item_t(fill));
            bound_.resize(0);
            for(std::size_t i=0; i < nbitems; ++i)
                items_[i].reset(fill);
        }
        prefix_.resize(0);
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
    clear () {



        (static_cast <bool> (bound_.size()==0 || num_args_ == static_cast<int>(bound_.size())) ? void (0) : __assert_fail ("bound_.size()==0 || num_args_ == static_cast<int>(bound_.size())", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp", 135, __extension__ __PRETTY_FUNCTION__));

        for(unsigned long i=0; i<items_.size(); ++i) {

            if( bound_.size()==0 || items_[i].argN_<0 || !bound_[ items_[i].argN_ ] )
                items_[i].res_.resize(0);
        }
        cur_arg_=0; dumped_=false;

        if(bound_.size() != 0) {
            for(; cur_arg_ < num_args_ && bound_[cur_arg_]; ++cur_arg_)
                {}
        }
        return *this;
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
    clear_binds () {

        bound_.resize(0);
        clear();
        return *this;
    }

    template< class Ch, class Tr, class Alloc>
    basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
    clear_bind (int argN) {

        if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] ) {
            if( exceptions() & io::out_of_range_bit)
                boost::throw_exception(io::out_of_range(argN, 1, num_args_+1 ) );
            else return *this;
        }
        bound_[argN-1]=false;
        clear();
        return *this;
    }

    template< class Ch, class Tr, class Alloc>
    int basic_format<Ch,Tr, Alloc>::
    bound_args() const {
        if(bound_.size()==0)
            return 0;
        int n=0;
        for(int i=0; i<num_args_ ; ++i)
            if(bound_[i])
                ++n;
        return n;
    }

    template< class Ch, class Tr, class Alloc>
    int basic_format<Ch,Tr, Alloc>::
    fed_args() const {
        if(bound_.size()==0)
            return cur_arg_;
        int n=0;
        for(int i=0; i<cur_arg_ ; ++i)
            if(!bound_[i])
                ++n;
        return n;
    }

    template< class Ch, class Tr, class Alloc>
    int basic_format<Ch,Tr, Alloc>::
    cur_arg() const {
      return cur_arg_+1; }

    template< class Ch, class Tr, class Alloc>
    int basic_format<Ch,Tr, Alloc>::
    remaining_args() const {
        if(bound_.size()==0)
            return num_args_-cur_arg_;
        int n=0;
        for(int i=cur_arg_; i<num_args_ ; ++i)
            if(!bound_[i])
                ++n;
        return n;
    }

    template< class Ch, class Tr, class Alloc>
    typename basic_format<Ch, Tr, Alloc>::string_type
    basic_format<Ch,Tr, Alloc>::
    str () const {
        if(items_.size()==0)
            return prefix_;
        if( cur_arg_ < num_args_)
            if( exceptions() & io::too_few_args_bit )

                boost::throw_exception(io::too_few_args(cur_arg_, num_args_));

        unsigned long i;
        string_type res;
        res.reserve(size());
        res += prefix_;
        for(i=0; i < items_.size(); ++i) {
            const format_item_t& item = items_[i];
            res += item.res_;
            if( item.argN_ == format_item_t::argN_tabulation) {
                (static_cast <bool> (item.pad_scheme_ & format_item_t::tabulation) ? void (0) : __assert_fail ("item.pad_scheme_ & format_item_t::tabulation", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp", 234, __extension__ __PRETTY_FUNCTION__));
                if( static_cast<size_type>(item.fmtstate_.width_) > res.size() )
                    res.append( static_cast<size_type>(item.fmtstate_.width_) - res.size(),
                                        item.fmtstate_.fill_ );
            }
            res += item.appendix_;
        }
        dumped_=true;
        return res;
    }
    template< class Ch, class Tr, class Alloc>
    typename std::basic_string<Ch, Tr, Alloc>::size_type basic_format<Ch,Tr, Alloc>::
    size () const {







        using std::max;
        size_type sz = prefix_.size();
        unsigned long i;
        for(i=0; i < items_.size(); ++i) {
            const format_item_t& item = items_[i];
            sz += item.res_.size();
            if( item.argN_ == format_item_t::argN_tabulation)
                sz = max (sz,
                                        static_cast<size_type>(item.fmtstate_.width_) );
            sz += item.appendix_.size();
        }
        return sz;



    }

namespace io {
namespace detail {

    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    bind_arg_body (basic_format<Ch, Tr, Alloc>& self, int argN, const T& val) {


        if(self.dumped_)
            self.clear();
        if(argN<1 || argN > self.num_args_) {
            if( self.exceptions() & io::out_of_range_bit )
                boost::throw_exception(io::out_of_range(argN, 1, self.num_args_+1 ) );
            else return self;
        }
        if(self.bound_.size()==0)
            self.bound_.assign(self.num_args_,false);
        else
            (static_cast <bool> (self.num_args_ == static_cast<signed int>(self.bound_.size())) ? void (0) : __assert_fail ("self.num_args_ == static_cast<signed int>(self.bound_.size())", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp", 289, __extension__ __PRETTY_FUNCTION__));
        int o_cur_arg = self.cur_arg_;
        self.cur_arg_ = argN-1;

        self.bound_[self.cur_arg_]=false;
        self.operator%(val);



        self.cur_arg_ = o_cur_arg;
        self.bound_[argN-1]=true;
        if(self.cur_arg_ == argN-1 ) {

            while(self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_])
                ++self.cur_arg_;
        }

        (static_cast <bool> (self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]) ? void (0) : __assert_fail ("self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/format_implementation.hpp", 306, __extension__ __PRETTY_FUNCTION__));
        return self;
    }

    template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>&
    modify_item_body (basic_format<Ch, Tr, Alloc>& self, int itemN, T manipulator) {


        if(itemN<1 || itemN > static_cast<signed int>(self.items_.size() )) {
            if( self.exceptions() & io::out_of_range_bit )
                boost::throw_exception(io::out_of_range(itemN, 1, static_cast<int>(self.items_.size()) ));
            else return self;
        }
        self.items_[itemN-1].fmtstate_. template apply_manip<T> ( manipulator );
        return self;
    }

}
}
}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/group.hpp" 1 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/group.hpp" 3
namespace boost {
namespace io {


namespace detail {



struct group0
{
    group0() {}
};

template <class Ch, class Tr>
inline
::std:: basic_ostream<Ch, Tr>&
operator << ( ::std:: basic_ostream<Ch, Tr>& os,
             const group0& )
{
   return os;
}

template <class T1>
struct group1
{
    T1 a1_;
    group1(T1 a1)
      : a1_(a1)
      {}
    group1(const group1&) = default;
    group1& operator=(const group1&) = delete;
};

template <class Ch, class Tr, class T1>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group1<T1>& x)
{
   os << x.a1_;
   return os;
}




template <class T1,class T2>
struct group2
{
    T1 a1_;
    T2 a2_;
    group2(T1 a1,T2 a2)
      : a1_(a1),a2_(a2)
      {}
    group2(const group2&) = default;
    group2& operator=(const group2&) = delete;
};

template <class Ch, class Tr, class T1,class T2>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group2<T1,T2>& x)
{
   os << x.a1_<< x.a2_;
   return os;
}

template <class T1,class T2,class T3>
struct group3
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    group3(T1 a1,T2 a2,T3 a3)
      : a1_(a1),a2_(a2),a3_(a3)
      {}
    group3(const group3&) = default;
    group3& operator=(const group3&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group3<T1,T2,T3>& x)
{
   os << x.a1_<< x.a2_<< x.a3_;
   return os;
}

template <class T1,class T2,class T3,class T4>
struct group4
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    group4(T1 a1,T2 a2,T3 a3,T4 a4)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4)
      {}
    group4(const group4&) = default;
    group4& operator=(const group4&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group4<T1,T2,T3,T4>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5>
struct group5
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    group5(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5)
      {}
    group5(const group5&) = default;
    group5& operator=(const group5&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group5<T1,T2,T3,T4,T5>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5,class T6>
struct group6
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    T6 a6_;
    group6(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6)
      {}
    group6(const group6&) = default;
    group6& operator=(const group6&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group6<T1,T2,T3,T4,T5,T6>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct group7
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    T6 a6_;
    T7 a7_;
    group7(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7)
      {}
    group7(const group7&) = default;
    group7& operator=(const group7&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group7<T1,T2,T3,T4,T5,T6,T7>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct group8
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    T6 a6_;
    T7 a7_;
    T8 a8_;
    group8(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8)
      {}
    group8(const group8&) = default;
    group8& operator=(const group8&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group8<T1,T2,T3,T4,T5,T6,T7,T8>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct group9
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    T6 a6_;
    T7 a7_;
    T8 a8_;
    T9 a9_;
    group9(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8),a9_(a9)
      {}
    group9(const group9&) = default;
    group9& operator=(const group9&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group9<T1,T2,T3,T4,T5,T6,T7,T8,T9>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_;
   return os;
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct group10
{
    T1 a1_;
    T2 a2_;
    T3 a3_;
    T4 a4_;
    T5 a5_;
    T6 a6_;
    T7 a7_;
    T8 a8_;
    T9 a9_;
    T10 a10_;
    group10(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9,T10 a10)
      : a1_(a1),a2_(a2),a3_(a3),a4_(a4),a5_(a5),a6_(a6),a7_(a7),a8_(a8),a9_(a9),a10_(a10)
      {}
    group10(const group10&) = default;
    group10& operator=(const group10&) = delete;
};

template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
inline
::std:: basic_ostream<Ch, Tr>&
operator << (::std:: basic_ostream<Ch, Tr>& os,
             const group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>& x)
{
   os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_<< x.a10_;
   return os;
}




template <class T1,class T2>
inline
group1<T1>
group_head( group2<T1,T2> const& x)
{
   return group1<T1> (x.a1_);
}

template <class T1,class T2>
inline
group1<T2>
group_last( group2<T1,T2> const& x)
{
   return group1<T2> (x.a2_);
}



template <class T1,class T2,class T3>
inline
group2<T1,T2>
group_head( group3<T1,T2,T3> const& x)
{
   return group2<T1,T2> (x.a1_,x.a2_);
}

template <class T1,class T2,class T3>
inline
group1<T3>
group_last( group3<T1,T2,T3> const& x)
{
   return group1<T3> (x.a3_);
}



template <class T1,class T2,class T3,class T4>
inline
group3<T1,T2,T3>
group_head( group4<T1,T2,T3,T4> const& x)
{
   return group3<T1,T2,T3> (x.a1_,x.a2_,x.a3_);
}

template <class T1,class T2,class T3,class T4>
inline
group1<T4>
group_last( group4<T1,T2,T3,T4> const& x)
{
   return group1<T4> (x.a4_);
}



template <class T1,class T2,class T3,class T4,class T5>
inline
group4<T1,T2,T3,T4>
group_head( group5<T1,T2,T3,T4,T5> const& x)
{
   return group4<T1,T2,T3,T4> (x.a1_,x.a2_,x.a3_,x.a4_);
}

template <class T1,class T2,class T3,class T4,class T5>
inline
group1<T5>
group_last( group5<T1,T2,T3,T4,T5> const& x)
{
   return group1<T5> (x.a5_);
}



template <class T1,class T2,class T3,class T4,class T5,class T6>
inline
group5<T1,T2,T3,T4,T5>
group_head( group6<T1,T2,T3,T4,T5,T6> const& x)
{
   return group5<T1,T2,T3,T4,T5> (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_);
}

template <class T1,class T2,class T3,class T4,class T5,class T6>
inline
group1<T6>
group_last( group6<T1,T2,T3,T4,T5,T6> const& x)
{
   return group1<T6> (x.a6_);
}



template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
inline
group6<T1,T2,T3,T4,T5,T6>
group_head( group7<T1,T2,T3,T4,T5,T6,T7> const& x)
{
   return group6<T1,T2,T3,T4,T5,T6> (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_);
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7>
inline
group1<T7>
group_last( group7<T1,T2,T3,T4,T5,T6,T7> const& x)
{
   return group1<T7> (x.a7_);
}



template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
inline
group7<T1,T2,T3,T4,T5,T6,T7>
group_head( group8<T1,T2,T3,T4,T5,T6,T7,T8> const& x)
{
   return group7<T1,T2,T3,T4,T5,T6,T7> (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_);
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
inline
group1<T8>
group_last( group8<T1,T2,T3,T4,T5,T6,T7,T8> const& x)
{
   return group1<T8> (x.a8_);
}



template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
inline
group8<T1,T2,T3,T4,T5,T6,T7,T8>
group_head( group9<T1,T2,T3,T4,T5,T6,T7,T8,T9> const& x)
{
   return group8<T1,T2,T3,T4,T5,T6,T7,T8> (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_,x.a8_);
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
inline
group1<T9>
group_last( group9<T1,T2,T3,T4,T5,T6,T7,T8,T9> const& x)
{
   return group1<T9> (x.a9_);
}



template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
inline
group9<T1,T2,T3,T4,T5,T6,T7,T8,T9>
group_head( group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> const& x)
{
   return group9<T1,T2,T3,T4,T5,T6,T7,T8,T9> (x.a1_,x.a2_,x.a3_,x.a4_,x.a5_,x.a6_,x.a7_,x.a8_,x.a9_);
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
inline
group1<T10>
group_last( group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> const& x)
{
   return group1<T10> (x.a10_);
}





}






inline detail::group1< detail::group0 >
group() { return detail::group1< detail::group0 > ( detail::group0() ); }

template <class T1, class Var>
inline
detail::group1< detail::group2<T1, Var const&> >
  group(T1 a1, Var const& var)
{
   return detail::group1< detail::group2<T1, Var const&> >
                   ( detail::group2<T1, Var const&>
                        (a1, var)
                  );
}

template <class T1,class T2, class Var>
inline
detail::group1< detail::group3<T1,T2, Var const&> >
  group(T1 a1,T2 a2, Var const& var)
{
   return detail::group1< detail::group3<T1,T2, Var const&> >
                   ( detail::group3<T1,T2, Var const&>
                        (a1,a2, var)
                  );
}

template <class T1,class T2,class T3, class Var>
inline
detail::group1< detail::group4<T1,T2,T3, Var const&> >
  group(T1 a1,T2 a2,T3 a3, Var const& var)
{
   return detail::group1< detail::group4<T1,T2,T3, Var const&> >
                   ( detail::group4<T1,T2,T3, Var const&>
                        (a1,a2,a3, var)
                  );
}

template <class T1,class T2,class T3,class T4, class Var>
inline
detail::group1< detail::group5<T1,T2,T3,T4, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4, Var const& var)
{
   return detail::group1< detail::group5<T1,T2,T3,T4, Var const&> >
                   ( detail::group5<T1,T2,T3,T4, Var const&>
                        (a1,a2,a3,a4, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5, class Var>
inline
detail::group1< detail::group6<T1,T2,T3,T4,T5, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5, Var const& var)
{
   return detail::group1< detail::group6<T1,T2,T3,T4,T5, Var const&> >
                   ( detail::group6<T1,T2,T3,T4,T5, Var const&>
                        (a1,a2,a3,a4,a5, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6, class Var>
inline
detail::group1< detail::group7<T1,T2,T3,T4,T5,T6, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6, Var const& var)
{
   return detail::group1< detail::group7<T1,T2,T3,T4,T5,T6, Var const&> >
                   ( detail::group7<T1,T2,T3,T4,T5,T6, Var const&>
                        (a1,a2,a3,a4,a5,a6, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7, class Var>
inline
detail::group1< detail::group8<T1,T2,T3,T4,T5,T6,T7, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7, Var const& var)
{
   return detail::group1< detail::group8<T1,T2,T3,T4,T5,T6,T7, Var const&> >
                   ( detail::group8<T1,T2,T3,T4,T5,T6,T7, Var const&>
                        (a1,a2,a3,a4,a5,a6,a7, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8, class Var>
inline
detail::group1< detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, Var const& var)
{
   return detail::group1< detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var const&> >
                   ( detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var const&>
                        (a1,a2,a3,a4,a5,a6,a7,a8, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9, class Var>
inline
detail::group1< detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var const&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9, Var const& var)
{
   return detail::group1< detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var const&> >
                   ( detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var const&>
                        (a1,a2,a3,a4,a5,a6,a7,a8,a9, var)
                  );
}




template <class T1, class Var>
inline
detail::group1< detail::group2<T1, Var&> >
  group(T1 a1, Var& var)
{
   return detail::group1< detail::group2<T1, Var&> >
                   ( detail::group2<T1, Var&>
                        (a1, var)
                  );
}

template <class T1,class T2, class Var>
inline
detail::group1< detail::group3<T1,T2, Var&> >
  group(T1 a1,T2 a2, Var& var)
{
   return detail::group1< detail::group3<T1,T2, Var&> >
                   ( detail::group3<T1,T2, Var&>
                        (a1,a2, var)
                  );
}

template <class T1,class T2,class T3, class Var>
inline
detail::group1< detail::group4<T1,T2,T3, Var&> >
  group(T1 a1,T2 a2,T3 a3, Var& var)
{
   return detail::group1< detail::group4<T1,T2,T3, Var&> >
                   ( detail::group4<T1,T2,T3, Var&>
                        (a1,a2,a3, var)
                  );
}

template <class T1,class T2,class T3,class T4, class Var>
inline
detail::group1< detail::group5<T1,T2,T3,T4, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4, Var& var)
{
   return detail::group1< detail::group5<T1,T2,T3,T4, Var&> >
                   ( detail::group5<T1,T2,T3,T4, Var&>
                        (a1,a2,a3,a4, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5, class Var>
inline
detail::group1< detail::group6<T1,T2,T3,T4,T5, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5, Var& var)
{
   return detail::group1< detail::group6<T1,T2,T3,T4,T5, Var&> >
                   ( detail::group6<T1,T2,T3,T4,T5, Var&>
                        (a1,a2,a3,a4,a5, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6, class Var>
inline
detail::group1< detail::group7<T1,T2,T3,T4,T5,T6, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6, Var& var)
{
   return detail::group1< detail::group7<T1,T2,T3,T4,T5,T6, Var&> >
                   ( detail::group7<T1,T2,T3,T4,T5,T6, Var&>
                        (a1,a2,a3,a4,a5,a6, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7, class Var>
inline
detail::group1< detail::group8<T1,T2,T3,T4,T5,T6,T7, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7, Var& var)
{
   return detail::group1< detail::group8<T1,T2,T3,T4,T5,T6,T7, Var&> >
                   ( detail::group8<T1,T2,T3,T4,T5,T6,T7, Var&>
                        (a1,a2,a3,a4,a5,a6,a7, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8, class Var>
inline
detail::group1< detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, Var& var)
{
   return detail::group1< detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var&> >
                   ( detail::group9<T1,T2,T3,T4,T5,T6,T7,T8, Var&>
                        (a1,a2,a3,a4,a5,a6,a7,a8, var)
                  );
}

template <class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9, class Var>
inline
detail::group1< detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var&> >
  group(T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9, Var& var)
{
   return detail::group1< detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var&> >
                   ( detail::group10<T1,T2,T3,T4,T5,T6,T7,T8,T9, Var&>
                        (a1,a2,a3,a4,a5,a6,a7,a8,a9, var)
                  );
}





}

}
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/msvc_disambiguater.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 2 3

namespace boost {
namespace io {
namespace detail {

    template<class Ch, class Tr, class Alloc>
    void mk_str( std::basic_string<Ch,Tr, Alloc> & res,
                 const Ch * beg,
                 typename std::basic_string<Ch,Tr,Alloc>::size_type size,
                 std::streamsize w,
                 const Ch fill_char,
                 std::ios_base::fmtflags f,
                 const Ch prefix_space,
                 bool center)


    {
        typedef typename std::basic_string<Ch,Tr,Alloc>::size_type size_type;
        res.resize(0);
        if(w<=0 || static_cast<size_type>(w) <=size) {

            res.reserve(size + !!prefix_space);
            if(prefix_space)
              res.append(1, prefix_space);
            if (size)
              res.append(beg, size);
        }
        else {
            std::streamsize n=static_cast<std::streamsize>(w-size-!!prefix_space);
            std::streamsize n_after = 0, n_before = 0;
            res.reserve(static_cast<size_type>(w));
            if(center)
                n_after = n/2, n_before = n - n_after;
            else
                if(f & std::ios_base::left)
                    n_after = n;
                else
                    n_before = n;

            if(n_before) res.append(static_cast<size_type>(n_before), fill_char);
            if(prefix_space)
              res.append(1, prefix_space);
            if (size)
              res.append(beg, size);
            if(n_after) res.append(static_cast<size_type>(n_after), fill_char);
        }
    }
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 3
    template< class Ch, class Tr, class T> inline
    void put_head (::std:: basic_ostream<Ch, Tr> &, const T& ) {
    }

    template< class Ch, class Tr, class T> inline
    void put_head( ::std:: basic_ostream<Ch, Tr> & os, const group1<T>& x ) {
        os << group_head(x.a1_);
    }

    template< class Ch, class Tr, class T> inline
    void put_last( ::std:: basic_ostream<Ch, Tr> & os, const T& x ) {
        os << x ;
    }

    template< class Ch, class Tr, class T> inline
    void put_last( ::std:: basic_ostream<Ch, Tr> & os, const group1<T>& x ) {
        os << group_last(x.a1_);
    }


    template< class Ch, class Tr, class T> inline
    void put_head( ::std:: basic_ostream<Ch, Tr> &, T& ) {
    }

    template< class Ch, class Tr, class T> inline
    void put_last( ::std:: basic_ostream<Ch, Tr> & os, T& x) {
        os << x ;
    }



    template< class Ch, class Tr, class T>
    void call_put_head(::std:: basic_ostream<Ch, Tr> & os, const void* x) {
        put_head(os, *(static_cast<T const *>(x)));
    }

    template< class Ch, class Tr, class T>
    void call_put_last(::std:: basic_ostream<Ch, Tr> & os, const void* x) {
        put_last(os, *(static_cast<T const *>(x)));
    }

    template< class Ch, class Tr>
    struct put_holder {
        template<class T>
        put_holder(T& t)
          : arg(&t),
            put_head(&call_put_head<Ch, Tr, T>),
            put_last(&call_put_last<Ch, Tr, T>)
        {}
        const void* arg;
        void (*put_head)(::std:: basic_ostream<Ch, Tr> & os, const void* x);
        void (*put_last)(::std:: basic_ostream<Ch, Tr> & os, const void* x);
    };

    template< class Ch, class Tr> inline
    void put_head( ::std:: basic_ostream<Ch, Tr> & os, const put_holder<Ch, Tr>& t) {
        t.put_head(os, t.arg);
    }

    template< class Ch, class Tr> inline
    void put_last( ::std:: basic_ostream<Ch, Tr> & os, const put_holder<Ch, Tr>& t) {
        t.put_last(os, t.arg);
    }


    template< class Ch, class Tr, class Alloc, class T>
    void put( T x,
              const format_item<Ch, Tr, Alloc>& specs,
              typename basic_format<Ch, Tr, Alloc>::string_type& res,
              typename basic_format<Ch, Tr, Alloc>::internal_streambuf_t & buf,
              io::detail::locale_t *loc_p = __null)
    {
# 170 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp" 3
        typedef typename basic_format<Ch, Tr, Alloc>::string_type string_type;
        typedef typename basic_format<Ch, Tr, Alloc>::format_item_t format_item_t;
        typedef typename string_type::size_type size_type;

        basic_oaltstringstream<Ch, Tr, Alloc> oss( &buf);


        if(loc_p != __null)
            oss.imbue(*loc_p);


        specs.fmtstate_.apply_on(oss, loc_p);


        put_head( oss, x );



        const std::ios_base::fmtflags fl=oss.flags();
        const bool internal = (fl & std::ios_base::internal) != 0;
        const std::streamsize w = oss.width();
        const bool two_stepped_padding= internal && (w!=0);

        res.resize(0);
        if(! two_stepped_padding) {
            if(w>0)
                oss.width(0);
            put_last( oss, x);
            const Ch * res_beg = buf.pbase();
            Ch prefix_space = 0;
            if(specs.pad_scheme_ & format_item_t::spacepad)
                if(buf.pcount()== 0 ||
                   (res_beg[0] !=oss.widen('+') && res_beg[0] !=oss.widen('-') ))
                    prefix_space = oss.widen(' ');
            size_type res_size = (std::min)(
                (static_cast<size_type>((specs.truncate_ & (std::numeric_limits<size_type>::max)())) - !!prefix_space),
                buf.pcount() );
            mk_str(res, res_beg, res_size, w, oss.fill(), fl,
                   prefix_space, (specs.pad_scheme_ & format_item_t::centered) !=0 );
        }
        else {



            put_last( oss, x);
            const Ch * res_beg = buf.pbase();
            size_type res_size = buf.pcount();
            bool prefix_space=false;
            if(specs.pad_scheme_ & format_item_t::spacepad)
                if(buf.pcount()== 0 ||
                   (res_beg[0] !=oss.widen('+') && res_beg[0] !=oss.widen('-') ))
                    prefix_space = true;
            if(res_size == static_cast<size_type>(w) && w<=specs.truncate_ && !prefix_space) {

                res.assign(res_beg, res_size);
            }
            else {



                res.assign(res_beg, res_size);
                res_beg=__null;


                buf.clear_buffer();
                basic_oaltstringstream<Ch, Tr, Alloc> oss2( &buf);
                specs.fmtstate_.apply_on(oss2, loc_p);
                put_head( oss2, x );

                oss2.width(0);
                if(prefix_space)
                    oss2 << ' ';
                put_last(oss2, x );
                if(buf.pcount()==0 && specs.pad_scheme_ & format_item_t::spacepad) {
                    prefix_space =true;
                    oss2 << ' ';
                }

                const Ch * tmp_beg = buf.pbase();
                size_type tmp_size = (std::min)(
                    (static_cast<size_type>(specs.truncate_ & (std::numeric_limits<size_type>::max)())),
                    buf.pcount());

                if(static_cast<size_type>(w) <= tmp_size) {

                        res.assign(tmp_beg, tmp_size);
                }
                else {

                    size_type sz = (std::min)(res_size + (prefix_space ? 1 : 0), tmp_size);
                    size_type i = prefix_space;
                    for(; i<sz && tmp_beg[i] == res[i - (prefix_space ? 1 : 0)]; ++i) {}
                    if(i>=tmp_size) i=prefix_space;
                    res.assign(tmp_beg, i);
                                        std::streamsize d = w - static_cast<std::streamsize>(tmp_size);
                                        (static_cast <bool> (d>0) ? void (0) : __assert_fail ("d>0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp", 265, __extension__ __PRETTY_FUNCTION__));
                    res.append(static_cast<size_type>( d ), oss2.fill());
                    res.append(tmp_beg+i, tmp_size-i);
                    (static_cast <bool> (i+(tmp_size-i)+(std::max)(d,(std::streamsize)0) == static_cast<size_type>(w)) ? void (0) : __assert_fail ("i+(tmp_size-i)+(std::max)(d,(std::streamsize)0) == static_cast<size_type>(w)", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp", 269, __extension__ __PRETTY_FUNCTION__));

                    (static_cast <bool> (res.size() == static_cast<size_type>(w)) ? void (0) : __assert_fail ("res.size() == static_cast<size_type>(w)", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/feed_args.hpp", 270, __extension__ __PRETTY_FUNCTION__));
                }
            }
        }
        buf.clear_buffer();



    }


    template< class Ch, class Tr, class Alloc, class T>
    void distribute (basic_format<Ch,Tr, Alloc>& self, T x) {

        if(self.cur_arg_ >= self.num_args_) {
            if( self.exceptions() & too_many_args_bit )
                boost::throw_exception(too_many_args(self.cur_arg_, self.num_args_));
            else return;
        }
        for(unsigned long i=0; i < self.items_.size(); ++i) {
            if(self.items_[i].argN_ == self.cur_arg_) {
                put<Ch, Tr, Alloc, T> (x, self.items_[i], self.items_[i].res_,
                                self.buf_, boost::get_pointer(self.loc_) );
            }
        }
    }

    template<class Ch, class Tr, class Alloc, class T>
    basic_format<Ch, Tr, Alloc>&
    feed_impl (basic_format<Ch,Tr, Alloc>& self, T x) {
        if(self.dumped_) self.clear();
        distribute<Ch, Tr, Alloc, T> (self, x);
        ++self.cur_arg_;
        if(self.bound_.size() != 0) {
                while( self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_] )
                    ++self.cur_arg_;
        }
        return self;
    }

    template<class Ch, class Tr, class Alloc, class T> inline
    basic_format<Ch, Tr, Alloc>&
    feed (basic_format<Ch,Tr, Alloc>& self, T x) {
        return feed_impl<Ch, Tr, Alloc, const put_holder<Ch, Tr>&>(self, put_holder<Ch, Tr>(x));
    }

}
}
}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/assert.hpp" 2 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 2 3



namespace boost {
namespace io {
namespace detail {
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 3
    template<class T>
    const T& const_or_not(const T& x) {
        return x;
    }


    template<class Ch, class Facet> inline
    char wrap_narrow(const Facet& fac, Ch c, char deflt) {
        return const_or_not(fac).narrow(c, deflt);
    }

    template<class Ch, class Facet> inline
    bool wrap_isdigit(const Facet& fac, Ch c) {

        return fac.is(std::ctype<Ch>::digit, c);





    }

    template<class Iter, class Facet>
    Iter wrap_scan_notdigit(const Facet & fac, Iter beg, Iter end) {
        using namespace std;
        for( ; beg!=end && wrap_isdigit(fac, *beg); ++beg) ;
        return beg;
    }






    template<class Res, class Iter, class Facet>
    Iter str2int (const Iter & start, const Iter & last, Res & res,
                 const Facet& fac)
    {
        using namespace std;
        Iter it;
        res=0;
        for(it=start; it != last && wrap_isdigit(fac, *it); ++it ) {
            char cur_ch = wrap_narrow(fac, *it, 0);
            res *= 10;
            res += cur_ch - '0';
        }
        return it;
    }




    inline void maybe_throw_exception(unsigned char exceptions,
                                      std::size_t pos, std::size_t size)
    {
        if(exceptions & io::bad_format_string_bit)
            boost::throw_exception(io::bad_format_string(pos, size) );
    }
# 106 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 3
    template<class Ch, class Tr, class Alloc, class Iter, class Facet>
    bool parse_printf_directive(Iter & start, const Iter& last,
                                detail::format_item<Ch, Tr, Alloc> * fpar,
                                const Facet& fac,
                                std::size_t offset, unsigned char exceptions)
    {
        typedef typename basic_format<Ch, Tr, Alloc>::format_item_t format_item_t;

        fpar->argN_ = format_item_t::argN_no_posit;
        bool precision_set = false;
        bool in_brackets=false;
        Iter start0 = start;
        std::size_t fstring_size = last-start0+offset;
        char mssiz = 0;

        if(start>= last) {
                maybe_throw_exception(exceptions, start-start0 + offset, fstring_size);
                return false;
        }

        if(*start== const_or_not(fac).widen( '|')) {
            in_brackets=true;
            if( ++start >= last ) {
                maybe_throw_exception(exceptions, start-start0 + offset, fstring_size);
                return false;
            }
        }


        if(*start== const_or_not(fac).widen( '0'))
            goto parse_flags;


        if(wrap_isdigit(fac, *start)) {
            int n;
            start = str2int(start, last, n, fac);
            if( start >= last ) {
                maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
                return false;
            }


            if( *start == const_or_not(fac).widen( '%') ) {
                fpar->argN_ = n-1;
                ++start;
                if( in_brackets)
                    maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
                return true;
            }

            if ( *start== const_or_not(fac).widen( '$') ) {
                fpar->argN_ = n-1;
                ++start;
            }
            else {

                fpar->fmtstate_.width_ = n;
                fpar->argN_ = format_item_t::argN_no_posit;
                goto parse_precision;
            }
        }

      parse_flags:

        while (start != last) {
            switch ( wrap_narrow(fac, *start, 0)) {
                case '\'':
                    break;
                case '-':
                    fpar->fmtstate_.flags_ |= std::ios_base::left;
                    break;
                case '=':
                    fpar->pad_scheme_ |= format_item_t::centered;
                    break;
                case '_':
                    fpar->fmtstate_.flags_ |= std::ios_base::internal;
                    break;
                case ' ':
                    fpar->pad_scheme_ |= format_item_t::spacepad;
                    break;
                case '+':
                    fpar->fmtstate_.flags_ |= std::ios_base::showpos;
                    break;
                case '0':
                    fpar->pad_scheme_ |= format_item_t::zeropad;


                    break;
                case '#':
                    fpar->fmtstate_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase;
                    break;
                default:
                    goto parse_width;
            }
            ++start;
        }

        if( start>=last) {
            maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
            return true;
        }


      parse_width:
        if(*start == const_or_not(fac).widen( '*') )
            ++start;
        else if(start!=last && wrap_isdigit(fac, *start))
            start = str2int(start, last, fpar->fmtstate_.width_, fac);

      parse_precision:
        if( start>= last) {
            maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
            return true;
        }

        if (*start== const_or_not(fac).widen( '.')) {
            ++start;
            if(start != last && *start == const_or_not(fac).widen( '*') )
                ++start;
            else if(start != last && wrap_isdigit(fac, *start)) {
                start = str2int(start, last, fpar->fmtstate_.precision_, fac);
                precision_set = true;
            }
            else
                fpar->fmtstate_.precision_ =0;
        }


        while (start != last) {
            switch (wrap_narrow(fac, *start, 0)) {
                case 'h':
                case 'l':
                case 'j':
                case 'z':
                case 'L':


                    break;
# 252 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp" 3
                case 'w':
                    break;
                case 'I':
                    mssiz = 'I';
                    break;
                case '3':
                    if (mssiz != 'I') {
                        maybe_throw_exception(exceptions, start - start0 + offset, fstring_size);
                        return true;
                    }
                    mssiz = '3';
                    break;
                case '2':
                    if (mssiz != '3') {
                        maybe_throw_exception(exceptions, start - start0 + offset, fstring_size);
                        return true;
                    }
                    mssiz = 0x00;
                    break;
                case '6':
                    if (mssiz != 'I') {
                        maybe_throw_exception(exceptions, start - start0 + offset, fstring_size);
                        return true;
                    }
                    mssiz = '6';
                    break;
                case '4':
                    if (mssiz != '6') {
                        maybe_throw_exception(exceptions, start - start0 + offset, fstring_size);
                        return true;
                    }
                    mssiz = 0x00;
                    break;
                default:
                    if (mssiz && mssiz == 'I') {
                        mssiz = 0;
                    }
                    goto parse_conversion_specification;
            }
            ++start;
        }

      parse_conversion_specification:
        if (start >= last || mssiz) {
            maybe_throw_exception(exceptions, start - start0 + offset, fstring_size);
            return true;
        }

        if( in_brackets && *start== const_or_not(fac).widen( '|') ) {
            ++start;
            return true;
        }




        switch (wrap_narrow(fac, *start, 0))
        {

            case 'b':
                fpar->fmtstate_.flags_ |= std::ios_base::boolalpha;
                break;


            case 'u':
            case 'd':
            case 'i':

                break;


            case 'X':
                fpar->fmtstate_.flags_ |= std::ios_base::uppercase;
                [[clang::fallthrough]];
            case 'x':
            case 'p':
                fpar->fmtstate_.flags_ &= ~std::ios_base::basefield;
                fpar->fmtstate_.flags_ |= std::ios_base::hex;
                break;


            case 'o':
                fpar->fmtstate_.flags_ &= ~std::ios_base::basefield;
                fpar->fmtstate_.flags_ |= std::ios_base::oct;
                break;


            case 'A':
                fpar->fmtstate_.flags_ |= std::ios_base::uppercase;
                [[clang::fallthrough]];
            case 'a':
                fpar->fmtstate_.flags_ &= ~std::ios_base::basefield;
                fpar->fmtstate_.flags_ |= std::ios_base::fixed;
                fpar->fmtstate_.flags_ |= std::ios_base::scientific;
                break;
            case 'E':
                fpar->fmtstate_.flags_ |= std::ios_base::uppercase;
                [[clang::fallthrough]];
            case 'e':
                fpar->fmtstate_.flags_ |= std::ios_base::scientific;
                break;
            case 'F':
                fpar->fmtstate_.flags_ |= std::ios_base::uppercase;
                [[clang::fallthrough]];
            case 'f':
                fpar->fmtstate_.flags_ |= std::ios_base::fixed;
                break;
            case 'G':
                fpar->fmtstate_.flags_ |= std::ios_base::uppercase;
                [[clang::fallthrough]];
            case 'g':

                break;


            case 'T':
                ++start;
                if( start >= last) {
                    maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
                    return false;
                } else {
                    fpar->fmtstate_.fill_ = *start;
                }
                fpar->pad_scheme_ |= format_item_t::tabulation;
                fpar->argN_ = format_item_t::argN_tabulation;
                break;
            case 't':
                fpar->fmtstate_.fill_ = const_or_not(fac).widen( ' ');
                fpar->pad_scheme_ |= format_item_t::tabulation;
                fpar->argN_ = format_item_t::argN_tabulation;
                break;


            case 'C':
            case 'c':
                fpar->truncate_ = 1;
                break;


            case 'S':
            case 's':
                if(precision_set)
                    fpar->truncate_ = fpar->fmtstate_.precision_;
                fpar->fmtstate_.precision_ = 6;
                break;


            case 'n' :
                fpar->argN_ = format_item_t::argN_ignored;
                break;

            default:
                maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
        }
        ++start;

        if( in_brackets ) {
            if( start != last && *start== const_or_not(fac).widen( '|') ) {
                ++start;
                return true;
            }
            else maybe_throw_exception(exceptions, start-start0+offset, fstring_size);
        }
        return true;
    }


    template<class String, class Facet>
    int upper_bound_from_fstring(const String& buf,
                                 const typename String::value_type arg_mark,
                                 const Facet& fac,
                                 unsigned char exceptions)
    {


        using namespace boost::io;
        typename String::size_type i1=0;
        int num_items=0;
        while( (i1=buf.find(arg_mark,i1)) != String::npos ) {
            if( i1+1 >= buf.size() ) {
                if(exceptions & bad_format_string_bit)
                    boost::throw_exception(bad_format_string(i1, buf.size() ));
                else {
                  ++num_items;
                  break;
                }
            }
            if(buf[i1+1] == buf[i1] ) {
                i1+=2; continue;
            }

            ++i1;

            i1 = detail::wrap_scan_notdigit(fac, buf.begin()+i1, buf.end()) - buf.begin();
            if( i1 < buf.size() && buf[i1] == arg_mark )
                ++i1;
            ++num_items;
        }
        return num_items;
    }
    template<class String> inline
    void append_string(String& dst, const String& src,
                       const typename String::size_type beg,
                       const typename String::size_type end) {
        dst.append(src.begin()+beg, src.begin()+end);
    }

}
}






    template<class Ch, class Tr, class Alloc>
    basic_format<Ch, Tr, Alloc>& basic_format<Ch, Tr, Alloc>::
    parse (const string_type& buf) {

        using namespace std;

        const std::ctype<Ch> & fac = std::use_facet< std::ctype<Ch> >(getloc());





        const Ch arg_mark = io::detail::const_or_not(fac).widen( '%');
        bool ordered_args=true;
        int max_argN=-1;


        int num_items = io::detail::upper_bound_from_fstring(buf, arg_mark, fac, exceptions());
        make_or_reuse_data(num_items);


        num_items=0;
        typename string_type::size_type i0=0, i1=0;
        typename string_type::const_iterator it;
        bool special_things=false;
        int cur_item=0;
        while( (i1=buf.find(arg_mark,i1)) != string_type::npos ) {
            string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_;
            if( buf[i1+1] == buf[i1] ) {
                io::detail::append_string(piece, buf, i0, i1+1);
                i1+=2; i0=i1;
                continue;
            }
            (static_cast <bool> (static_cast<unsigned int>(cur_item) < items_.size() || cur_item==0) ? void (0) : __assert_fail ("static_cast<unsigned int>(cur_item) < items_.size() || cur_item==0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp", 500, __extension__ __PRETTY_FUNCTION__));

            if(i1!=i0) {
                io::detail::append_string(piece, buf, i0, i1);
                i0=i1;
            }
            ++i1;
            it = buf.begin()+i1;
            bool parse_ok = io::detail::parse_printf_directive(
                it, buf.end(), &items_[cur_item], fac, i1, exceptions());
            i1 = it - buf.begin();
            if( ! parse_ok )
                continue;
            i0=i1;
            items_[cur_item].compute_states();

            int argN=items_[cur_item].argN_;
            if(argN == format_item_t::argN_ignored)
                continue;
            if(argN ==format_item_t::argN_no_posit)
                ordered_args=false;
            else if(argN == format_item_t::argN_tabulation) special_things=true;
            else if(argN > max_argN) max_argN = argN;
            ++num_items;
            ++cur_item;
        }
        (static_cast <bool> (cur_item == num_items) ? void (0) : __assert_fail ("cur_item == num_items", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/parsing.hpp", 526, __extension__ __PRETTY_FUNCTION__));


        {
            string_type & piece = (cur_item==0) ? prefix_ : items_[cur_item-1].appendix_;
            io::detail::append_string(piece, buf, i0, buf.size());
        }

        if( !ordered_args) {
            if(max_argN >= 0 ) {
                if(exceptions() & io::bad_format_string_bit)
                    boost::throw_exception(
                        io::bad_format_string(static_cast<std::size_t>(max_argN), 0));

            }

            int non_ordered_items = 0;
            for(int i=0; i< num_items; ++i)
                if(items_[i].argN_ == format_item_t::argN_no_posit) {
                    items_[i].argN_ = non_ordered_items;
                    ++non_ordered_items;
                }
            max_argN = non_ordered_items-1;
        }


        items_.resize(num_items, format_item_t(io::detail::const_or_not(fac).widen( ' ')) );

        if(special_things) style_ |= special_needs;
        num_args_ = max_argN + 1;
        if(ordered_args) style_ |= ordered;
        else style_ &= ~ordered;
        return *this;
    }

}
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/free_funcs.hpp" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/free_funcs.hpp" 3
namespace boost {

    template<class Ch, class Tr, class Alloc> inline
    std::basic_string<Ch, Tr, Alloc> str(const basic_format<Ch, Tr, Alloc>& f) {

        return f.str();
    }
    namespace io {
         using ::boost::str;
    }


        template<class Ch, class Tr, class Alloc>
        std::basic_ostream<Ch, Tr> &
        operator<<( std::basic_ostream<Ch, Tr> & os,
                    const basic_format<Ch, Tr, Alloc>& f)







    {
        typedef boost::basic_format<Ch, Tr, Alloc> format_t;
        if(f.items_.size()==0)
            os << f.prefix_;
        else {
            if(f.cur_arg_ < f.num_args_)
                if( f.exceptions() & io::too_few_args_bit )

                    boost::throw_exception(io::too_few_args(f.cur_arg_, f.num_args_));
            if(f.style_ & format_t::special_needs)
                os << f.str();
            else {

                os << f.prefix_;
                for(unsigned long i=0; i<f.items_.size(); ++i) {
                    const typename format_t::format_item_t& item = f.items_[i];
                    os << item.res_;
                    os << item.appendix_;
                }
            }
        }
        f.dumped_=true;
        return os;
    }

}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format/detail/unset_macros.hpp" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/format.hpp" 2 3
# 11 "include/framework/core/FrameworkExceptions.h" 2

namespace Belle2 {
# 49 "include/framework/core/FrameworkExceptions.h"
}
# 12 "include/framework/gearbox/Interface.h" 2
# 1 "include/framework/gearbox/Unit.h" 1
# 14 "include/framework/gearbox/Unit.h"
namespace Belle2 {
# 36 "include/framework/gearbox/Unit.h"
  class Unit {

  public:




    static const double cm;
    static const double ns;
    static const double GHz;
    static const double rad;
    static const double GeV;
    static const double K;
    static const double e;






    static const double g_cm3;







    static const double km;
    static const double m;
    static const double mm;
    static const double um;
    static const double nm;
    static const double pm;
    static const double fm;


    static const double m2;
    static const double cm2;
    static const double mm2;

    static const double b;
    static const double mb;
    static const double ub;
    static const double nb;
    static const double pb;
    static const double fb;
    static const double ab;


    static const double m3;
    static const double cm3;
    static const double mm3;


    static const double s;
    static const double ms;
    static const double us;
    static const double ps;
    static const double fs;


    static const double Hz;
    static const double kHz;
    static const double MHz;
    static const double mHz;


    static const double mrad;
    static const double deg;


    static const double eV;
    static const double keV;
    static const double MeV;
    static const double TeV;
    static const double J;
    static const double V;


    static const double T;
    static const double mT;
    static const double Gauss;
    static const double kGauss;


    static const double C;
    static const double fC;


    static const double mg_cm3;
    static const double kg_cm3;
    static const double g_mm3;
    static const double mg_mm3;
    static const double kg_mm3;
# 142 "include/framework/gearbox/Unit.h"
    static double convertValue(double value, const std::string& unitString);
# 153 "include/framework/gearbox/Unit.h"
    static double convertValueToUnit(double value, const std::string& unitString);

  protected:

    static double registerConversion(const std::string& name, double value);

    static std::map<std::string, double> s_conversionFactors;

  private:




    Unit() = delete;
    Unit(const Unit&) = delete;
    Unit& operator=(const Unit&) = delete;
    ~Unit() = delete;

  };

}
# 13 "include/framework/gearbox/Interface.h" 2



class TObject;

namespace Belle2 {

  class GearDir;

  namespace gearbox {

    class PathEmptyError : public std::runtime_error { public: PathEmptyError(): std::runtime_error(""), m_format("Path '%1%' does not exist or is empty") { } ~PathEmptyError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> PathEmptyError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };

    class ConversionError : public std::runtime_error { public: ConversionError(): std::runtime_error(""), m_format("Path '%1%': Could not convert '%2%' to numerical value") { } ~ConversionError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> ConversionError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };

    class TObjectConversionError : public std::runtime_error { public: TObjectConversionError(): std::runtime_error(""), m_format("Path '%1%': Could not convert to TObject! Malformed data?") { } ~TObjectConversionError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> TObjectConversionError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };


    class Interface {
    public:


      Interface(): m_path("/") {}


      virtual ~Interface() {}





      virtual int getNumberNodes(const std::string& path = "") const = 0;





      bool exists(const std::string& path = "") const { return getNumberNodes(path) > 0; }





      operator bool() const { return exists(); }






      std::vector<GearDir> getNodes(const std::string& path = "") const;


      std::string getPath() const { return m_path; }







      virtual std::string getString(const std::string& path = "") const noexcept(false) = 0;
# 87 "include/framework/gearbox/Interface.h"
      virtual std::pair<std::string, std::string> getStringWithUnit(const std::string& path) const noexcept(false) = 0;
# 97 "include/framework/gearbox/Interface.h"
      std::string getString(const std::string& path, const std::string& defaultValue) const;
# 108 "include/framework/gearbox/Interface.h"
      virtual const TObject* getTObject(const std::string& path) const noexcept(false) = 0;
# 117 "include/framework/gearbox/Interface.h"
      double getDouble(const std::string& path = "") const noexcept(false);
# 128 "include/framework/gearbox/Interface.h"
      double getDouble(const std::string& path, double defaultValue) const noexcept(false);
# 137 "include/framework/gearbox/Interface.h"
      int getInt(const std::string& path = "") const noexcept(false);
# 148 "include/framework/gearbox/Interface.h"
      int getInt(const std::string& path, int defaultValue) const noexcept(false);







      bool getBool(const std::string& path = "") const noexcept(false);
# 166 "include/framework/gearbox/Interface.h"
      bool getBool(const std::string& path, bool defaultValue) const;
# 181 "include/framework/gearbox/Interface.h"
      double getWithUnit(const std::string& path) const noexcept(false);
# 199 "include/framework/gearbox/Interface.h"
      double getWithUnit(const std::string& path, double defaultValue) const noexcept(false);
# 218 "include/framework/gearbox/Interface.h"
      std::vector<double> getArray(const std::string& path) const noexcept(false);
# 239 "include/framework/gearbox/Interface.h"
      std::vector<double> getArray(const std::string& path, const std::vector<double>& defaultValue) const noexcept(false);
# 255 "include/framework/gearbox/Interface.h"
      double getLength(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 277 "include/framework/gearbox/Interface.h"
      double getLength(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }
# 295 "include/framework/gearbox/Interface.h"
      double getAngle(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 317 "include/framework/gearbox/Interface.h"
      double getAngle(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }
# 335 "include/framework/gearbox/Interface.h"
      double getEnergy(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 357 "include/framework/gearbox/Interface.h"
      double getEnergy(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }
# 375 "include/framework/gearbox/Interface.h"
      double getDensity(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 397 "include/framework/gearbox/Interface.h"
      double getDensity(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }
# 415 "include/framework/gearbox/Interface.h"
      double getTime(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 437 "include/framework/gearbox/Interface.h"
      double getTime(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }
# 455 "include/framework/gearbox/Interface.h"
      double getFrequency(const std::string& path = "") const noexcept(false)
      {
        return getWithUnit(path);
      }
# 477 "include/framework/gearbox/Interface.h"
      double getFrequency(const std::string& path, double defaultValue) const noexcept(false)
      {
        return getWithUnit(path, defaultValue);
      }

    protected:


      std::string ensureNode(const std::string& path) const ;

      std::string ensurePath(const std::string& path) const;

      std::string addIndex(const std::string& path, int index) const;

      std::string joinPath(const std::string& path, const std::string& subpath) const;


      std::string m_path;

    };
  }
}
# 12 "include/framework/gearbox/GearDir.h" 2
# 1 "include/framework/gearbox/Gearbox.h" 1
# 11 "include/framework/gearbox/Gearbox.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h" 1
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlversion.h" 1
# 251 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlversion.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlexports.h" 1
# 87 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlexports.h"
extern "C" {


          void xmlCheckVersion(int version);


}
# 252 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlversion.h" 2
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h" 2



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h" 1
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
extern "C" {
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
typedef enum {

    XML_ERR_NONE = 0,






    XML_ERR_WARNING = 1,
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
    XML_ERR_ERROR = 2,
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
    XML_ERR_FATAL = 3
} xmlErrorLevel;




typedef enum {

    XML_FROM_NONE = 0,

    XML_FROM_PARSER,

    XML_FROM_TREE,

    XML_FROM_NAMESPACE,

    XML_FROM_DTD,

    XML_FROM_HTML,

    XML_FROM_MEMORY,

    XML_FROM_OUTPUT,

    XML_FROM_IO,

    XML_FROM_FTP,

    XML_FROM_HTTP,

    XML_FROM_XINCLUDE,

    XML_FROM_XPATH,

    XML_FROM_XPOINTER,

    XML_FROM_REGEXP,

    XML_FROM_DATATYPE,

    XML_FROM_SCHEMASP,

    XML_FROM_SCHEMASV,

    XML_FROM_RELAXNGP,

    XML_FROM_RELAXNGV,

    XML_FROM_CATALOG,

    XML_FROM_C14N,

    XML_FROM_XSLT,

    XML_FROM_VALID,

    XML_FROM_CHECK,

    XML_FROM_WRITER,

    XML_FROM_MODULE,

    XML_FROM_I18N,

    XML_FROM_SCHEMATRONV,

    XML_FROM_BUFFER,

    XML_FROM_URI
} xmlErrorDomain;


typedef struct _xmlError xmlError;
typedef xmlError *xmlErrorPtr;



struct _xmlError {

    int domain;

    int code;

    char *message;

    xmlErrorLevel level;

    char *file;

    int line;

    char *str1;

    char *str2;

    char *str3;

    int int1;

    int int2;

    void *ctxt;

    void *node;
};




typedef enum {

    XML_ERR_OK = 0,

    XML_ERR_INTERNAL_ERROR,

    XML_ERR_NO_MEMORY,
    XML_ERR_DOCUMENT_START,
    XML_ERR_DOCUMENT_EMPTY,
    XML_ERR_DOCUMENT_END,
    XML_ERR_INVALID_HEX_CHARREF,
    XML_ERR_INVALID_DEC_CHARREF,
    XML_ERR_INVALID_CHARREF,
    XML_ERR_INVALID_CHAR,
    XML_ERR_CHARREF_AT_EOF,
    XML_ERR_CHARREF_IN_PROLOG,
    XML_ERR_CHARREF_IN_EPILOG,
    XML_ERR_CHARREF_IN_DTD,
    XML_ERR_ENTITYREF_AT_EOF,
    XML_ERR_ENTITYREF_IN_PROLOG,
    XML_ERR_ENTITYREF_IN_EPILOG,
    XML_ERR_ENTITYREF_IN_DTD,
    XML_ERR_PEREF_AT_EOF,
    XML_ERR_PEREF_IN_PROLOG,
    XML_ERR_PEREF_IN_EPILOG,
    XML_ERR_PEREF_IN_INT_SUBSET,
    XML_ERR_ENTITYREF_NO_NAME,
    XML_ERR_ENTITYREF_SEMICOL_MISSING,
    XML_ERR_PEREF_NO_NAME,
    XML_ERR_PEREF_SEMICOL_MISSING,
    XML_ERR_UNDECLARED_ENTITY,
    XML_WAR_UNDECLARED_ENTITY,
    XML_ERR_UNPARSED_ENTITY,
    XML_ERR_ENTITY_IS_EXTERNAL,
    XML_ERR_ENTITY_IS_PARAMETER,
    XML_ERR_UNKNOWN_ENCODING,

    XML_ERR_UNSUPPORTED_ENCODING,
    XML_ERR_STRING_NOT_STARTED,
    XML_ERR_STRING_NOT_CLOSED,
    XML_ERR_NS_DECL_ERROR,
    XML_ERR_ENTITY_NOT_STARTED,
    XML_ERR_ENTITY_NOT_FINISHED,
    XML_ERR_LT_IN_ATTRIBUTE,
    XML_ERR_ATTRIBUTE_NOT_STARTED,
    XML_ERR_ATTRIBUTE_NOT_FINISHED,
    XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
    XML_ERR_ATTRIBUTE_REDEFINED,
    XML_ERR_LITERAL_NOT_STARTED,
    XML_ERR_LITERAL_NOT_FINISHED,
    XML_ERR_COMMENT_NOT_FINISHED,
    XML_ERR_PI_NOT_STARTED,
    XML_ERR_PI_NOT_FINISHED,
    XML_ERR_NOTATION_NOT_STARTED,
    XML_ERR_NOTATION_NOT_FINISHED,
    XML_ERR_ATTLIST_NOT_STARTED,
    XML_ERR_ATTLIST_NOT_FINISHED,
    XML_ERR_MIXED_NOT_STARTED,
    XML_ERR_MIXED_NOT_FINISHED,
    XML_ERR_ELEMCONTENT_NOT_STARTED,
    XML_ERR_ELEMCONTENT_NOT_FINISHED,
    XML_ERR_XMLDECL_NOT_STARTED,
    XML_ERR_XMLDECL_NOT_FINISHED,
    XML_ERR_CONDSEC_NOT_STARTED,
    XML_ERR_CONDSEC_NOT_FINISHED,
    XML_ERR_EXT_SUBSET_NOT_FINISHED,
    XML_ERR_DOCTYPE_NOT_FINISHED,
    XML_ERR_MISPLACED_CDATA_END,
    XML_ERR_CDATA_NOT_FINISHED,
    XML_ERR_RESERVED_XML_NAME,
    XML_ERR_SPACE_REQUIRED,
    XML_ERR_SEPARATOR_REQUIRED,
    XML_ERR_NMTOKEN_REQUIRED,
    XML_ERR_NAME_REQUIRED,
    XML_ERR_PCDATA_REQUIRED,
    XML_ERR_URI_REQUIRED,
    XML_ERR_PUBID_REQUIRED,
    XML_ERR_LT_REQUIRED,
    XML_ERR_GT_REQUIRED,
    XML_ERR_LTSLASH_REQUIRED,
    XML_ERR_EQUAL_REQUIRED,
    XML_ERR_TAG_NAME_MISMATCH,
    XML_ERR_TAG_NOT_FINISHED,
    XML_ERR_STANDALONE_VALUE,
    XML_ERR_ENCODING_NAME,
    XML_ERR_HYPHEN_IN_COMMENT,
    XML_ERR_INVALID_ENCODING,
    XML_ERR_EXT_ENTITY_STANDALONE,
    XML_ERR_CONDSEC_INVALID,
    XML_ERR_VALUE_REQUIRED,
    XML_ERR_NOT_WELL_BALANCED,
    XML_ERR_EXTRA_CONTENT,
    XML_ERR_ENTITY_CHAR_ERROR,
    XML_ERR_ENTITY_PE_INTERNAL,
    XML_ERR_ENTITY_LOOP,
    XML_ERR_ENTITY_BOUNDARY,
    XML_ERR_INVALID_URI,
    XML_ERR_URI_FRAGMENT,
    XML_WAR_CATALOG_PI,
    XML_ERR_NO_DTD,
    XML_ERR_CONDSEC_INVALID_KEYWORD,
    XML_ERR_VERSION_MISSING,
    XML_WAR_UNKNOWN_VERSION,
    XML_WAR_LANG_VALUE,
    XML_WAR_NS_URI,
    XML_WAR_NS_URI_RELATIVE,
    XML_ERR_MISSING_ENCODING,
    XML_WAR_SPACE_VALUE,
    XML_ERR_NOT_STANDALONE,
    XML_ERR_ENTITY_PROCESSING,
    XML_ERR_NOTATION_PROCESSING,
    XML_WAR_NS_COLUMN,
    XML_WAR_ENTITY_REDEFINED,
    XML_ERR_UNKNOWN_VERSION,
    XML_ERR_VERSION_MISMATCH,
    XML_ERR_NAME_TOO_LONG,
    XML_ERR_USER_STOP,
    XML_ERR_COMMENT_ABRUPTLY_ENDED,
    XML_WAR_ENCODING_MISMATCH,




    XML_ERR_RESOURCE_LIMIT,

    XML_ERR_ARGUMENT,

    XML_ERR_SYSTEM,
    XML_ERR_REDECL_PREDEF_ENTITY,
    XML_ERR_INT_SUBSET_NOT_FINISHED,
    XML_NS_ERR_XML_NAMESPACE = 200,
    XML_NS_ERR_UNDEFINED_NAMESPACE,
    XML_NS_ERR_QNAME,
    XML_NS_ERR_ATTRIBUTE_REDEFINED,
    XML_NS_ERR_EMPTY,
    XML_NS_ERR_COLON,
    XML_DTD_ATTRIBUTE_DEFAULT = 500,
    XML_DTD_ATTRIBUTE_REDEFINED,
    XML_DTD_ATTRIBUTE_VALUE,
    XML_DTD_CONTENT_ERROR,
    XML_DTD_CONTENT_MODEL,
    XML_DTD_CONTENT_NOT_DETERMINIST,
    XML_DTD_DIFFERENT_PREFIX,
    XML_DTD_ELEM_DEFAULT_NAMESPACE,
    XML_DTD_ELEM_NAMESPACE,
    XML_DTD_ELEM_REDEFINED,
    XML_DTD_EMPTY_NOTATION,
    XML_DTD_ENTITY_TYPE,
    XML_DTD_ID_FIXED,
    XML_DTD_ID_REDEFINED,
    XML_DTD_ID_SUBSET,
    XML_DTD_INVALID_CHILD,
    XML_DTD_INVALID_DEFAULT,
    XML_DTD_LOAD_ERROR,
    XML_DTD_MISSING_ATTRIBUTE,
    XML_DTD_MIXED_CORRUPT,
    XML_DTD_MULTIPLE_ID,
    XML_DTD_NO_DOC,
    XML_DTD_NO_DTD,
    XML_DTD_NO_ELEM_NAME,
    XML_DTD_NO_PREFIX,
    XML_DTD_NO_ROOT,
    XML_DTD_NOTATION_REDEFINED,
    XML_DTD_NOTATION_VALUE,
    XML_DTD_NOT_EMPTY,
    XML_DTD_NOT_PCDATA,
    XML_DTD_NOT_STANDALONE,
    XML_DTD_ROOT_NAME,
    XML_DTD_STANDALONE_WHITE_SPACE,
    XML_DTD_UNKNOWN_ATTRIBUTE,
    XML_DTD_UNKNOWN_ELEM,
    XML_DTD_UNKNOWN_ENTITY,
    XML_DTD_UNKNOWN_ID,
    XML_DTD_UNKNOWN_NOTATION,
    XML_DTD_STANDALONE_DEFAULTED,
    XML_DTD_XMLID_VALUE,
    XML_DTD_XMLID_TYPE,
    XML_DTD_DUP_TOKEN,
    XML_HTML_STRUCURE_ERROR = 800,
    XML_HTML_UNKNOWN_TAG,
    XML_HTML_INCORRECTLY_OPENED_COMMENT,
    XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
    XML_RNGP_ATTR_CONFLICT,
    XML_RNGP_ATTRIBUTE_CHILDREN,
    XML_RNGP_ATTRIBUTE_CONTENT,
    XML_RNGP_ATTRIBUTE_EMPTY,
    XML_RNGP_ATTRIBUTE_NOOP,
    XML_RNGP_CHOICE_CONTENT,
    XML_RNGP_CHOICE_EMPTY,
    XML_RNGP_CREATE_FAILURE,
    XML_RNGP_DATA_CONTENT,
    XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
    XML_RNGP_DEFINE_CREATE_FAILED,
    XML_RNGP_DEFINE_EMPTY,
    XML_RNGP_DEFINE_MISSING,
    XML_RNGP_DEFINE_NAME_MISSING,
    XML_RNGP_ELEM_CONTENT_EMPTY,
    XML_RNGP_ELEM_CONTENT_ERROR,
    XML_RNGP_ELEMENT_EMPTY,
    XML_RNGP_ELEMENT_CONTENT,
    XML_RNGP_ELEMENT_NAME,
    XML_RNGP_ELEMENT_NO_CONTENT,
    XML_RNGP_ELEM_TEXT_CONFLICT,
    XML_RNGP_EMPTY,
    XML_RNGP_EMPTY_CONSTRUCT,
    XML_RNGP_EMPTY_CONTENT,
    XML_RNGP_EMPTY_NOT_EMPTY,
    XML_RNGP_ERROR_TYPE_LIB,
    XML_RNGP_EXCEPT_EMPTY,
    XML_RNGP_EXCEPT_MISSING,
    XML_RNGP_EXCEPT_MULTIPLE,
    XML_RNGP_EXCEPT_NO_CONTENT,
    XML_RNGP_EXTERNALREF_EMTPY,
    XML_RNGP_EXTERNAL_REF_FAILURE,
    XML_RNGP_EXTERNALREF_RECURSE,
    XML_RNGP_FORBIDDEN_ATTRIBUTE,
    XML_RNGP_FOREIGN_ELEMENT,
    XML_RNGP_GRAMMAR_CONTENT,
    XML_RNGP_GRAMMAR_EMPTY,
    XML_RNGP_GRAMMAR_MISSING,
    XML_RNGP_GRAMMAR_NO_START,
    XML_RNGP_GROUP_ATTR_CONFLICT,
    XML_RNGP_HREF_ERROR,
    XML_RNGP_INCLUDE_EMPTY,
    XML_RNGP_INCLUDE_FAILURE,
    XML_RNGP_INCLUDE_RECURSE,
    XML_RNGP_INTERLEAVE_ADD,
    XML_RNGP_INTERLEAVE_CREATE_FAILED,
    XML_RNGP_INTERLEAVE_EMPTY,
    XML_RNGP_INTERLEAVE_NO_CONTENT,
    XML_RNGP_INVALID_DEFINE_NAME,
    XML_RNGP_INVALID_URI,
    XML_RNGP_INVALID_VALUE,
    XML_RNGP_MISSING_HREF,
    XML_RNGP_NAME_MISSING,
    XML_RNGP_NEED_COMBINE,
    XML_RNGP_NOTALLOWED_NOT_EMPTY,
    XML_RNGP_NSNAME_ATTR_ANCESTOR,
    XML_RNGP_NSNAME_NO_NS,
    XML_RNGP_PARAM_FORBIDDEN,
    XML_RNGP_PARAM_NAME_MISSING,
    XML_RNGP_PARENTREF_CREATE_FAILED,
    XML_RNGP_PARENTREF_NAME_INVALID,
    XML_RNGP_PARENTREF_NO_NAME,
    XML_RNGP_PARENTREF_NO_PARENT,
    XML_RNGP_PARENTREF_NOT_EMPTY,
    XML_RNGP_PARSE_ERROR,
    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
    XML_RNGP_PAT_ATTR_ATTR,
    XML_RNGP_PAT_ATTR_ELEM,
    XML_RNGP_PAT_DATA_EXCEPT_ATTR,
    XML_RNGP_PAT_DATA_EXCEPT_ELEM,
    XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
    XML_RNGP_PAT_DATA_EXCEPT_GROUP,
    XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
    XML_RNGP_PAT_DATA_EXCEPT_LIST,
    XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
    XML_RNGP_PAT_DATA_EXCEPT_REF,
    XML_RNGP_PAT_DATA_EXCEPT_TEXT,
    XML_RNGP_PAT_LIST_ATTR,
    XML_RNGP_PAT_LIST_ELEM,
    XML_RNGP_PAT_LIST_INTERLEAVE,
    XML_RNGP_PAT_LIST_LIST,
    XML_RNGP_PAT_LIST_REF,
    XML_RNGP_PAT_LIST_TEXT,
    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
    XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
    XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
    XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
    XML_RNGP_PAT_START_ATTR,
    XML_RNGP_PAT_START_DATA,
    XML_RNGP_PAT_START_EMPTY,
    XML_RNGP_PAT_START_GROUP,
    XML_RNGP_PAT_START_INTERLEAVE,
    XML_RNGP_PAT_START_LIST,
    XML_RNGP_PAT_START_ONEMORE,
    XML_RNGP_PAT_START_TEXT,
    XML_RNGP_PAT_START_VALUE,
    XML_RNGP_PREFIX_UNDEFINED,
    XML_RNGP_REF_CREATE_FAILED,
    XML_RNGP_REF_CYCLE,
    XML_RNGP_REF_NAME_INVALID,
    XML_RNGP_REF_NO_DEF,
    XML_RNGP_REF_NO_NAME,
    XML_RNGP_REF_NOT_EMPTY,
    XML_RNGP_START_CHOICE_AND_INTERLEAVE,
    XML_RNGP_START_CONTENT,
    XML_RNGP_START_EMPTY,
    XML_RNGP_START_MISSING,
    XML_RNGP_TEXT_EXPECTED,
    XML_RNGP_TEXT_HAS_CHILD,
    XML_RNGP_TYPE_MISSING,
    XML_RNGP_TYPE_NOT_FOUND,
    XML_RNGP_TYPE_VALUE,
    XML_RNGP_UNKNOWN_ATTRIBUTE,
    XML_RNGP_UNKNOWN_COMBINE,
    XML_RNGP_UNKNOWN_CONSTRUCT,
    XML_RNGP_UNKNOWN_TYPE_LIB,
    XML_RNGP_URI_FRAGMENT,
    XML_RNGP_URI_NOT_ABSOLUTE,
    XML_RNGP_VALUE_EMPTY,
    XML_RNGP_VALUE_NO_CONTENT,
    XML_RNGP_XMLNS_NAME,
    XML_RNGP_XML_NS,
    XML_XPATH_EXPRESSION_OK = 1200,
    XML_XPATH_NUMBER_ERROR,
    XML_XPATH_UNFINISHED_LITERAL_ERROR,
    XML_XPATH_START_LITERAL_ERROR,
    XML_XPATH_VARIABLE_REF_ERROR,
    XML_XPATH_UNDEF_VARIABLE_ERROR,
    XML_XPATH_INVALID_PREDICATE_ERROR,
    XML_XPATH_EXPR_ERROR,
    XML_XPATH_UNCLOSED_ERROR,
    XML_XPATH_UNKNOWN_FUNC_ERROR,
    XML_XPATH_INVALID_OPERAND,
    XML_XPATH_INVALID_TYPE,
    XML_XPATH_INVALID_ARITY,
    XML_XPATH_INVALID_CTXT_SIZE,
    XML_XPATH_INVALID_CTXT_POSITION,
    XML_XPATH_MEMORY_ERROR,
    XML_XPTR_SYNTAX_ERROR,
    XML_XPTR_RESOURCE_ERROR,
    XML_XPTR_SUB_RESOURCE_ERROR,
    XML_XPATH_UNDEF_PREFIX_ERROR,
    XML_XPATH_ENCODING_ERROR,
    XML_XPATH_INVALID_CHAR_ERROR,
    XML_TREE_INVALID_HEX = 1300,
    XML_TREE_INVALID_DEC,
    XML_TREE_UNTERMINATED_ENTITY,
    XML_TREE_NOT_UTF8,
    XML_SAVE_NOT_UTF8 = 1400,
    XML_SAVE_CHAR_INVALID,
    XML_SAVE_NO_DOCTYPE,
    XML_SAVE_UNKNOWN_ENCODING,
    XML_REGEXP_COMPILE_ERROR = 1450,
    XML_IO_UNKNOWN = 1500,
    XML_IO_EACCES,
    XML_IO_EAGAIN,
    XML_IO_EBADF,
    XML_IO_EBADMSG,
    XML_IO_EBUSY,
    XML_IO_ECANCELED,
    XML_IO_ECHILD,
    XML_IO_EDEADLK,
    XML_IO_EDOM,
    XML_IO_EEXIST,
    XML_IO_EFAULT,
    XML_IO_EFBIG,
    XML_IO_EINPROGRESS,
    XML_IO_EINTR,
    XML_IO_EINVAL,
    XML_IO_EIO,
    XML_IO_EISDIR,
    XML_IO_EMFILE,
    XML_IO_EMLINK,
    XML_IO_EMSGSIZE,
    XML_IO_ENAMETOOLONG,
    XML_IO_ENFILE,
    XML_IO_ENODEV,

    XML_IO_ENOENT,
    XML_IO_ENOEXEC,
    XML_IO_ENOLCK,
    XML_IO_ENOMEM,
    XML_IO_ENOSPC,
    XML_IO_ENOSYS,
    XML_IO_ENOTDIR,
    XML_IO_ENOTEMPTY,
    XML_IO_ENOTSUP,
    XML_IO_ENOTTY,
    XML_IO_ENXIO,
    XML_IO_EPERM,
    XML_IO_EPIPE,
    XML_IO_ERANGE,
    XML_IO_EROFS,
    XML_IO_ESPIPE,
    XML_IO_ESRCH,
    XML_IO_ETIMEDOUT,
    XML_IO_EXDEV,
    XML_IO_NETWORK_ATTEMPT,
    XML_IO_ENCODER,
    XML_IO_FLUSH,
    XML_IO_WRITE,
    XML_IO_NO_INPUT,
    XML_IO_BUFFER_FULL,
    XML_IO_LOAD_ERROR,
    XML_IO_ENOTSOCK,
    XML_IO_EISCONN,
    XML_IO_ECONNREFUSED,
    XML_IO_ENETUNREACH,
    XML_IO_EADDRINUSE,
    XML_IO_EALREADY,
    XML_IO_EAFNOSUPPORT,
    XML_IO_UNSUPPORTED_PROTOCOL,
    XML_XINCLUDE_RECURSION=1600,
    XML_XINCLUDE_PARSE_VALUE,
    XML_XINCLUDE_ENTITY_DEF_MISMATCH,
    XML_XINCLUDE_NO_HREF,
    XML_XINCLUDE_NO_FALLBACK,
    XML_XINCLUDE_HREF_URI,
    XML_XINCLUDE_TEXT_FRAGMENT,
    XML_XINCLUDE_TEXT_DOCUMENT,
    XML_XINCLUDE_INVALID_CHAR,
    XML_XINCLUDE_BUILD_FAILED,
    XML_XINCLUDE_UNKNOWN_ENCODING,
    XML_XINCLUDE_MULTIPLE_ROOT,
    XML_XINCLUDE_XPTR_FAILED,
    XML_XINCLUDE_XPTR_RESULT,
    XML_XINCLUDE_INCLUDE_IN_INCLUDE,
    XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
    XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
    XML_XINCLUDE_DEPRECATED_NS,
    XML_XINCLUDE_FRAGMENT_ID,
    XML_CATALOG_MISSING_ATTR = 1650,
    XML_CATALOG_ENTRY_BROKEN,
    XML_CATALOG_PREFER_VALUE,
    XML_CATALOG_NOT_CATALOG,
    XML_CATALOG_RECURSION,
    XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
    XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
    XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
    XML_SCHEMAP_ATTR_NONAME_NOREF,
    XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF,
    XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
    XML_SCHEMAP_ELEM_NONAME_NOREF,
    XML_SCHEMAP_EXTENSION_NO_BASE,
    XML_SCHEMAP_FACET_NO_VALUE,
    XML_SCHEMAP_FAILED_BUILD_IMPORT,
    XML_SCHEMAP_GROUP_NONAME_NOREF,
    XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
    XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
    XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
    XML_SCHEMAP_INVALID_BOOLEAN,
    XML_SCHEMAP_INVALID_ENUM,
    XML_SCHEMAP_INVALID_FACET,
    XML_SCHEMAP_INVALID_FACET_VALUE,
    XML_SCHEMAP_INVALID_MAXOCCURS,
    XML_SCHEMAP_INVALID_MINOCCURS,
    XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
    XML_SCHEMAP_INVALID_WHITE_SPACE,
    XML_SCHEMAP_NOATTR_NOREF,
    XML_SCHEMAP_NOTATION_NO_NAME,
    XML_SCHEMAP_NOTYPE_NOREF,
    XML_SCHEMAP_REF_AND_SUBTYPE,
    XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
    XML_SCHEMAP_SIMPLETYPE_NONAME,
    XML_SCHEMAP_TYPE_AND_SUBTYPE,
    XML_SCHEMAP_UNKNOWN_ALL_CHILD,
    XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
    XML_SCHEMAP_UNKNOWN_BASE_TYPE,
    XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
    XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
    XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
    XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
    XML_SCHEMAP_UNKNOWN_FACET_CHILD,
    XML_SCHEMAP_UNKNOWN_FACET_TYPE,
    XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
    XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
    XML_SCHEMAP_UNKNOWN_LIST_CHILD,
    XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
    XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_REF,
    XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
    XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
    XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
    XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
    XML_SCHEMAP_UNKNOWN_TYPE,
    XML_SCHEMAP_UNKNOWN_UNION_CHILD,
    XML_SCHEMAP_ELEM_DEFAULT_FIXED,
    XML_SCHEMAP_REGEXP_INVALID,
    XML_SCHEMAP_FAILED_LOAD,
    XML_SCHEMAP_NOTHING_TO_PARSE,
    XML_SCHEMAP_NOROOT,
    XML_SCHEMAP_REDEFINED_GROUP,
    XML_SCHEMAP_REDEFINED_TYPE,
    XML_SCHEMAP_REDEFINED_ELEMENT,
    XML_SCHEMAP_REDEFINED_ATTRGROUP,
    XML_SCHEMAP_REDEFINED_ATTR,
    XML_SCHEMAP_REDEFINED_NOTATION,
    XML_SCHEMAP_FAILED_PARSE,
    XML_SCHEMAP_UNKNOWN_PREFIX,
    XML_SCHEMAP_DEF_AND_PREFIX,
    XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
    XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
    XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
    XML_SCHEMAP_NOT_SCHEMA,
    XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
    XML_SCHEMAP_INVALID_ATTR_USE,
    XML_SCHEMAP_RECURSIVE,
    XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
    XML_SCHEMAP_INVALID_ATTR_COMBINATION,
    XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
    XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD,
    XML_SCHEMAP_INVALID_ATTR_NAME,
    XML_SCHEMAP_REF_AND_CONTENT,
    XML_SCHEMAP_CT_PROPS_CORRECT_1,
    XML_SCHEMAP_CT_PROPS_CORRECT_2,
    XML_SCHEMAP_CT_PROPS_CORRECT_3,
    XML_SCHEMAP_CT_PROPS_CORRECT_4,
    XML_SCHEMAP_CT_PROPS_CORRECT_5,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
    XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
    XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
    XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
    XML_SCHEMAP_SRC_IMPORT_3_1,
    XML_SCHEMAP_SRC_IMPORT_3_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
    XML_SCHEMAP_COS_CT_EXTENDS_1_3,
    XML_SCHEMAV_NOROOT = 1801,
    XML_SCHEMAV_UNDECLAREDELEM,
    XML_SCHEMAV_NOTTOPLEVEL,
    XML_SCHEMAV_MISSING,
    XML_SCHEMAV_WRONGELEM,
    XML_SCHEMAV_NOTYPE,
    XML_SCHEMAV_NOROLLBACK,
    XML_SCHEMAV_ISABSTRACT,
    XML_SCHEMAV_NOTEMPTY,
    XML_SCHEMAV_ELEMCONT,
    XML_SCHEMAV_HAVEDEFAULT,
    XML_SCHEMAV_NOTNILLABLE,
    XML_SCHEMAV_EXTRACONTENT,
    XML_SCHEMAV_INVALIDATTR,
    XML_SCHEMAV_INVALIDELEM,
    XML_SCHEMAV_NOTDETERMINIST,
    XML_SCHEMAV_CONSTRUCT,
    XML_SCHEMAV_INTERNAL,
    XML_SCHEMAV_NOTSIMPLE,
    XML_SCHEMAV_ATTRUNKNOWN,
    XML_SCHEMAV_ATTRINVALID,
    XML_SCHEMAV_VALUE,
    XML_SCHEMAV_FACET,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3,
    XML_SCHEMAV_CVC_TYPE_3_1_1,
    XML_SCHEMAV_CVC_TYPE_3_1_2,
    XML_SCHEMAV_CVC_FACET_VALID,
    XML_SCHEMAV_CVC_LENGTH_VALID,
    XML_SCHEMAV_CVC_MINLENGTH_VALID,
    XML_SCHEMAV_CVC_MAXLENGTH_VALID,
    XML_SCHEMAV_CVC_MININCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID,
    XML_SCHEMAV_CVC_TOTALDIGITS_VALID,
    XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID,
    XML_SCHEMAV_CVC_PATTERN_VALID,
    XML_SCHEMAV_CVC_ENUMERATION_VALID,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4,
    XML_SCHEMAV_CVC_ELT_1,
    XML_SCHEMAV_CVC_ELT_2,
    XML_SCHEMAV_CVC_ELT_3_1,
    XML_SCHEMAV_CVC_ELT_3_2_1,
    XML_SCHEMAV_CVC_ELT_3_2_2,
    XML_SCHEMAV_CVC_ELT_4_1,
    XML_SCHEMAV_CVC_ELT_4_2,
    XML_SCHEMAV_CVC_ELT_4_3,
    XML_SCHEMAV_CVC_ELT_5_1_1,
    XML_SCHEMAV_CVC_ELT_5_1_2,
    XML_SCHEMAV_CVC_ELT_5_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_2,
    XML_SCHEMAV_CVC_ELT_6,
    XML_SCHEMAV_CVC_ELT_7,
    XML_SCHEMAV_CVC_ATTRIBUTE_1,
    XML_SCHEMAV_CVC_ATTRIBUTE_2,
    XML_SCHEMAV_CVC_ATTRIBUTE_3,
    XML_SCHEMAV_CVC_ATTRIBUTE_4,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_4,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2,
    XML_SCHEMAV_ELEMENT_CONTENT,
    XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_1,
    XML_SCHEMAV_CVC_AU,
    XML_SCHEMAV_CVC_TYPE_1,
    XML_SCHEMAV_CVC_TYPE_2,
    XML_SCHEMAV_CVC_IDC,
    XML_SCHEMAV_CVC_WILDCARD,
    XML_SCHEMAV_MISC,
    XML_XPTR_UNKNOWN_SCHEME = 1900,
    XML_XPTR_CHILDSEQ_START,
    XML_XPTR_EVAL_FAILED,
    XML_XPTR_EXTRA_OBJECTS,
    XML_C14N_CREATE_CTXT = 1950,
    XML_C14N_REQUIRES_UTF8,
    XML_C14N_CREATE_STACK,
    XML_C14N_INVALID_NODE,
    XML_C14N_UNKNOW_NODE,
    XML_C14N_RELATIVE_NAMESPACE,
    XML_FTP_PASV_ANSWER = 2000,
    XML_FTP_EPSV_ANSWER,
    XML_FTP_ACCNT,
    XML_FTP_URL_SYNTAX,
    XML_HTTP_URL_SYNTAX = 2020,
    XML_HTTP_USE_IP,
    XML_HTTP_UNKNOWN_HOST,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_2,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
    XML_SCHEMAP_SRC_RESOLVE,
    XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
    XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
    XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
    XML_SCHEMAP_ST_PROPS_CORRECT_1,
    XML_SCHEMAP_ST_PROPS_CORRECT_2,
    XML_SCHEMAP_ST_PROPS_CORRECT_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_1,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_2,
    XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
    XML_SCHEMAP_S4S_ELEM_MISSING,
    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
    XML_SCHEMAP_S4S_ATTR_MISSING,
    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
    XML_SCHEMAP_SRC_ELEMENT_1,
    XML_SCHEMAP_SRC_ELEMENT_2_1,
    XML_SCHEMAP_SRC_ELEMENT_2_2,
    XML_SCHEMAP_SRC_ELEMENT_3,
    XML_SCHEMAP_P_PROPS_CORRECT_1,
    XML_SCHEMAP_P_PROPS_CORRECT_2_1,
    XML_SCHEMAP_P_PROPS_CORRECT_2_2,
    XML_SCHEMAP_E_PROPS_CORRECT_2,
    XML_SCHEMAP_E_PROPS_CORRECT_3,
    XML_SCHEMAP_E_PROPS_CORRECT_4,
    XML_SCHEMAP_E_PROPS_CORRECT_5,
    XML_SCHEMAP_E_PROPS_CORRECT_6,
    XML_SCHEMAP_SRC_INCLUDE,
    XML_SCHEMAP_SRC_ATTRIBUTE_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_4,
    XML_SCHEMAP_NO_XMLNS,
    XML_SCHEMAP_NO_XSI,
    XML_SCHEMAP_COS_VALID_DEFAULT_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2,
    XML_SCHEMAP_CVC_SIMPLE_TYPE,
    XML_SCHEMAP_COS_CT_EXTENDS_1_1,
    XML_SCHEMAP_SRC_IMPORT_1_1,
    XML_SCHEMAP_SRC_IMPORT_1_2,
    XML_SCHEMAP_SRC_IMPORT_2,
    XML_SCHEMAP_SRC_IMPORT_2_1,
    XML_SCHEMAP_SRC_IMPORT_2_2,
    XML_SCHEMAP_INTERNAL,
    XML_SCHEMAP_NOT_DETERMINISTIC,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
    XML_SCHEMAP_MG_PROPS_CORRECT_1,
    XML_SCHEMAP_MG_PROPS_CORRECT_2,
    XML_SCHEMAP_SRC_CT_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
    XML_SCHEMAP_AU_PROPS_CORRECT_2,
    XML_SCHEMAP_A_PROPS_CORRECT_2,
    XML_SCHEMAP_C_PROPS_CORRECT,
    XML_SCHEMAP_SRC_REDEFINE,
    XML_SCHEMAP_SRC_IMPORT,
    XML_SCHEMAP_WARN_SKIP_SCHEMA,
    XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
    XML_SCHEMAP_WARN_ATTR_REDECL_PROH,
    XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
    XML_SCHEMAP_AG_PROPS_CORRECT,
    XML_SCHEMAP_COS_CT_EXTENDS_1_2,
    XML_SCHEMAP_AU_PROPS_CORRECT,
    XML_SCHEMAP_A_PROPS_CORRECT_3,
    XML_SCHEMAP_COS_ALL_LIMITED,
    XML_SCHEMATRONV_ASSERT = 4000,
    XML_SCHEMATRONV_REPORT,
    XML_MODULE_OPEN = 4900,
    XML_MODULE_CLOSE,
    XML_CHECK_FOUND_ELEMENT = 5000,
    XML_CHECK_FOUND_ATTRIBUTE,
    XML_CHECK_FOUND_TEXT,
    XML_CHECK_FOUND_CDATA,
    XML_CHECK_FOUND_ENTITYREF,
    XML_CHECK_FOUND_ENTITY,
    XML_CHECK_FOUND_PI,
    XML_CHECK_FOUND_COMMENT,
    XML_CHECK_FOUND_DOCTYPE,
    XML_CHECK_FOUND_FRAGMENT,
    XML_CHECK_FOUND_NOTATION,
    XML_CHECK_UNKNOWN_NODE,
    XML_CHECK_ENTITY_TYPE,
    XML_CHECK_NO_PARENT,
    XML_CHECK_NO_DOC,
    XML_CHECK_NO_NAME,
    XML_CHECK_NO_ELEM,
    XML_CHECK_WRONG_DOC,
    XML_CHECK_NO_PREV,
    XML_CHECK_WRONG_PREV,
    XML_CHECK_NO_NEXT,
    XML_CHECK_WRONG_NEXT,
    XML_CHECK_NOT_DTD,
    XML_CHECK_NOT_ATTR,
    XML_CHECK_NOT_ATTR_DECL,
    XML_CHECK_NOT_ELEM_DECL,
    XML_CHECK_NOT_ENTITY_DECL,
    XML_CHECK_NOT_NS_DECL,
    XML_CHECK_NO_HREF,
    XML_CHECK_WRONG_PARENT,
    XML_CHECK_NS_SCOPE,
    XML_CHECK_NS_ANCESTOR,
    XML_CHECK_NOT_UTF8,
    XML_CHECK_NO_DICT,
    XML_CHECK_NOT_NCNAME,
    XML_CHECK_OUTSIDE_DICT,
    XML_CHECK_WRONG_NAME,
    XML_CHECK_NAME_NOT_NULL,
    XML_I18N_NO_NAME = 6000,
    XML_I18N_NO_HANDLER,
    XML_I18N_EXCESS_HANDLER,
    XML_I18N_CONV_FAILED,
    XML_I18N_NO_OUTPUT,
    XML_BUF_OVERFLOW = 7000
} xmlParserErrors;
# 944 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
typedef void (*xmlGenericErrorFunc) (void *ctx,
     const char *msg,
     ...) __attribute__((__format__(__printf__,2,3)));






typedef void (*xmlStructuredErrorFunc) (void *userData, const xmlError *error);


__attribute__((deprecated))
          const xmlError *__xmlLastError(void);
          xmlGenericErrorFunc *__xmlGenericError(void);
          void **__xmlGenericErrorContext(void);
          xmlStructuredErrorFunc *__xmlStructuredError(void);
          void **__xmlStructuredErrorContext(void);
# 1000 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlerror.h"
          void
    xmlSetGenericErrorFunc (void *ctx,
     xmlGenericErrorFunc handler);
          void
    xmlSetStructuredErrorFunc (void *ctx,
     xmlStructuredErrorFunc handler);

__attribute__((deprecated))
          void
    xmlThrDefSetGenericErrorFunc(void *ctx,
                                 xmlGenericErrorFunc handler);
__attribute__((deprecated))
          void
    xmlThrDefSetStructuredErrorFunc(void *ctx,
                                 xmlStructuredErrorFunc handler);




          void
    xmlParserError (void *ctx,
     const char *msg,
     ...) __attribute__((__format__(__printf__,2,3)));
          void
    xmlParserWarning (void *ctx,
     const char *msg,
     ...) __attribute__((__format__(__printf__,2,3)));
          void
    xmlParserValidityError (void *ctx,
     const char *msg,
     ...) __attribute__((__format__(__printf__,2,3)));
          void
    xmlParserValidityWarning (void *ctx,
     const char *msg,
     ...) __attribute__((__format__(__printf__,2,3)));
struct _xmlParserInput;
          void
    xmlParserPrintFileInfo (struct _xmlParserInput *input);
          void
    xmlParserPrintFileContext (struct _xmlParserInput *input);
          void
xmlFormatError (const xmlError *err,
     xmlGenericErrorFunc channel,
     void *data);




          const xmlError *
    xmlGetLastError (void);
          void
    xmlResetLastError (void);
          const xmlError *
    xmlCtxtGetLastError (void *ctx);
          void
    xmlCtxtResetLastError (void *ctx);
          void
    xmlResetError (xmlError *err);
          int
    xmlCopyError (const xmlError *from,
     xmlError *to);


}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 1
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlstring.h" 1
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlstring.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlstring.h" 2



extern "C" {







typedef unsigned char xmlChar;
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlstring.h"
          xmlChar *
                xmlStrdup (const xmlChar *cur);
          xmlChar *
                xmlStrndup (const xmlChar *cur,
                                         int len);
          xmlChar *
                xmlCharStrndup (const char *cur,
                                         int len);
          xmlChar *
                xmlCharStrdup (const char *cur);
          xmlChar *
                xmlStrsub (const xmlChar *str,
                                         int start,
                                         int len);
          const xmlChar *
                xmlStrchr (const xmlChar *str,
                                         xmlChar val);
          const xmlChar *
                xmlStrstr (const xmlChar *str,
                                         const xmlChar *val);
          const xmlChar *
                xmlStrcasestr (const xmlChar *str,
                                         const xmlChar *val);
          int
                xmlStrcmp (const xmlChar *str1,
                                         const xmlChar *str2);
          int
                xmlStrncmp (const xmlChar *str1,
                                         const xmlChar *str2,
                                         int len);
          int
                xmlStrcasecmp (const xmlChar *str1,
                                         const xmlChar *str2);
          int
                xmlStrncasecmp (const xmlChar *str1,
                                         const xmlChar *str2,
                                         int len);
          int
                xmlStrEqual (const xmlChar *str1,
                                         const xmlChar *str2);
          int
                xmlStrQEqual (const xmlChar *pref,
                                         const xmlChar *name,
                                         const xmlChar *str);
          int
                xmlStrlen (const xmlChar *str);
          xmlChar *
                xmlStrcat (xmlChar *cur,
                                         const xmlChar *add);
          xmlChar *
                xmlStrncat (xmlChar *cur,
                                         const xmlChar *add,
                                         int len);
          xmlChar *
                xmlStrncatNew (const xmlChar *str1,
                                         const xmlChar *str2,
                                         int len);
          int
                xmlStrPrintf (xmlChar *buf,
                                         int len,
                                         const char *msg,
                                         ...) __attribute__((__format__(__printf__,3,4)));
          int
                xmlStrVPrintf (xmlChar *buf,
                                         int len,
                                         const char *msg,
                                         va_list ap) __attribute__((__format__(__printf__,3,0)));

          int
        xmlGetUTF8Char (const unsigned char *utf,
                                         int *len);
          int
        xmlCheckUTF8 (const unsigned char *utf);
          int
        xmlUTF8Strsize (const xmlChar *utf,
                                         int len);
          xmlChar *
        xmlUTF8Strndup (const xmlChar *utf,
                                         int len);
          const xmlChar *
        xmlUTF8Strpos (const xmlChar *utf,
                                         int pos);
          int
        xmlUTF8Strloc (const xmlChar *utf,
                                         const xmlChar *utfchar);
          xmlChar *
        xmlUTF8Strsub (const xmlChar *utf,
                                         int start,
                                         int len);
          int
        xmlUTF8Strlen (const xmlChar *utf);
          int
        xmlUTF8Size (const xmlChar *utf);
          int
        xmlUTF8Charcmp (const xmlChar *utf1,
                                         const xmlChar *utf2);


}
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h" 1
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h"
extern "C" {
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h"
typedef void (*xmlFreeFunc)(void *mem);






typedef void *(*xmlMallocFunc)(size_t size) ;
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h"
typedef void *(*xmlReallocFunc)(void *mem, size_t size);







typedef char *(*xmlStrdupFunc)(const char *str);
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h"
extern xmlMallocFunc xmlMalloc;







extern xmlMallocFunc xmlMallocAtomic;



extern xmlReallocFunc xmlRealloc;



extern xmlFreeFunc xmlFree;



extern xmlStrdupFunc xmlMemStrdup;
# 118 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlmemory.h"
          int
 xmlMemSetup (xmlFreeFunc freeFunc,
    xmlMallocFunc mallocFunc,
    xmlReallocFunc reallocFunc,
    xmlStrdupFunc strdupFunc);
          int
 xmlMemGet (xmlFreeFunc *freeFunc,
    xmlMallocFunc *mallocFunc,
    xmlReallocFunc *reallocFunc,
    xmlStrdupFunc *strdupFunc);
__attribute__((deprecated))
          int
 xmlGcMemSetup (xmlFreeFunc freeFunc,
    xmlMallocFunc mallocFunc,
    xmlMallocFunc mallocAtomicFunc,
    xmlReallocFunc reallocFunc,
    xmlStrdupFunc strdupFunc);
__attribute__((deprecated))
          int
 xmlGcMemGet (xmlFreeFunc *freeFunc,
    xmlMallocFunc *mallocFunc,
    xmlMallocFunc *mallocAtomicFunc,
    xmlReallocFunc *reallocFunc,
    xmlStrdupFunc *strdupFunc);




__attribute__((deprecated))
          int
 xmlInitMemory (void);




__attribute__((deprecated))
          void
                xmlCleanupMemory (void);



          size_t
 xmlMemSize (void *ptr);
          int
 xmlMemUsed (void);
          int
 xmlMemBlocks (void);
__attribute__((deprecated))
          void
 xmlMemDisplay (FILE *fp);
__attribute__((deprecated))
          void
 xmlMemDisplayLast(FILE *fp, long nbBytes);
__attribute__((deprecated))
          void
 xmlMemShow (FILE *fp, int nr);
__attribute__((deprecated))
          void
 xmlMemoryDump (void);
          void *
 xmlMemMalloc (size_t size) ;
          void *
 xmlMemRealloc (void *ptr,size_t size);
          void
 xmlMemFree (void *ptr);
          char *
 xmlMemoryStrdup (const char *str);
__attribute__((deprecated))
          void *
 xmlMallocLoc (size_t size, const char *file, int line) ;
__attribute__((deprecated))
          void *
 xmlReallocLoc (void *ptr, size_t size, const char *file, int line);
__attribute__((deprecated))
          void *
 xmlMallocAtomicLoc (size_t size, const char *file, int line) ;
__attribute__((deprecated))
          char *
 xmlMemStrdupLoc (const char *str, const char *file, int line);


}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlregexp.h" 1
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlregexp.h"
extern "C" {





typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp *xmlRegexpPtr;




typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;




          xmlRegexp *
      xmlRegexpCompile (const xmlChar *regexp);
          void xmlRegFreeRegexp(xmlRegexp *regexp);
          int
      xmlRegexpExec (xmlRegexp *comp,
      const xmlChar *value);
__attribute__((deprecated))
          void
      xmlRegexpPrint (FILE *output,
      xmlRegexp *regexp);
          int
      xmlRegexpIsDeterminist(xmlRegexp *comp);
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlregexp.h"
typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxt *exec,
                              const xmlChar *token,
         void *transdata,
         void *inputdata);




__attribute__((deprecated))
          xmlRegExecCtxt *
      xmlRegNewExecCtxt (xmlRegexp *comp,
      xmlRegExecCallbacks callback,
      void *data);
__attribute__((deprecated))
          void
      xmlRegFreeExecCtxt (xmlRegExecCtxt *exec);
__attribute__((deprecated))
          int
      xmlRegExecPushString(xmlRegExecCtxt *exec,
      const xmlChar *value,
      void *data);
__attribute__((deprecated))
          int
      xmlRegExecPushString2(xmlRegExecCtxt *exec,
      const xmlChar *value,
      const xmlChar *value2,
      void *data);

__attribute__((deprecated))
          int
      xmlRegExecNextValues(xmlRegExecCtxt *exec,
      int *nbval,
      int *nbneg,
      xmlChar **values,
      int *terminal);
__attribute__((deprecated))
          int
      xmlRegExecErrInfo (xmlRegExecCtxt *exec,
      const xmlChar **string,
      int *nbval,
      int *nbneg,
      xmlChar **values,
      int *terminal);


}
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 2


extern "C" {
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;


typedef struct _xmlOutputBuffer xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;



typedef struct _xmlParserInput xmlParserInput;
typedef xmlParserInput *xmlParserInputPtr;


typedef struct _xmlParserCtxt xmlParserCtxt;
typedef xmlParserCtxt *xmlParserCtxtPtr;


typedef struct _xmlSAXLocator xmlSAXLocator;
typedef xmlSAXLocator *xmlSAXLocatorPtr;


typedef struct _xmlSAXHandler xmlSAXHandler;
typedef xmlSAXHandler *xmlSAXHandlerPtr;



typedef struct _xmlEntity xmlEntity;
typedef xmlEntity *xmlEntityPtr;




typedef enum {
    XML_BUFFER_ALLOC_DOUBLEIT,
    XML_BUFFER_ALLOC_EXACT,
    XML_BUFFER_ALLOC_IMMUTABLE,
    XML_BUFFER_ALLOC_IO,
    XML_BUFFER_ALLOC_HYBRID,
    XML_BUFFER_ALLOC_BOUNDED
} xmlBufferAllocationScheme;


typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;




struct _xmlBuffer {





    xmlChar *content __attribute__((deprecated));





    unsigned int use __attribute__((deprecated));

    unsigned int size __attribute__((deprecated));

    xmlBufferAllocationScheme alloc __attribute__((deprecated));

    xmlChar *contentIO __attribute__((deprecated));
};


typedef struct _xmlBuf xmlBuf;
typedef xmlBuf *xmlBufPtr;
# 162 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
typedef enum {





    XML_ELEMENT_NODE= 1,





    XML_ATTRIBUTE_NODE= 2,





    XML_TEXT_NODE= 3,





    XML_CDATA_SECTION_NODE= 4,






    XML_ENTITY_REF_NODE= 5,

    XML_ENTITY_NODE= 6,





    XML_PI_NODE= 7,





    XML_COMMENT_NODE= 8,





    XML_DOCUMENT_NODE= 9,

    XML_DOCUMENT_TYPE_NODE= 10,





    XML_DOCUMENT_FRAG_NODE= 11,

    XML_NOTATION_NODE= 12,





    XML_HTML_DOCUMENT_NODE= 13,





    XML_DTD_NODE= 14,





    XML_ELEMENT_DECL= 15,





    XML_ATTRIBUTE_DECL= 16,





    XML_ENTITY_DECL= 17,
# 265 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
    XML_NAMESPACE_DECL= 18,






    XML_XINCLUDE_START= 19,






    XML_XINCLUDE_END= 20

} xmlElementType;







typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;






struct _xmlNotation {

    const xmlChar *name;

    const xmlChar *PublicID;

    const xmlChar *SystemID;
};




typedef enum {
    XML_ATTRIBUTE_CDATA = 1,
    XML_ATTRIBUTE_ID,
    XML_ATTRIBUTE_IDREF ,
    XML_ATTRIBUTE_IDREFS,
    XML_ATTRIBUTE_ENTITY,
    XML_ATTRIBUTE_ENTITIES,
    XML_ATTRIBUTE_NMTOKEN,
    XML_ATTRIBUTE_NMTOKENS,
    XML_ATTRIBUTE_ENUMERATION,
    XML_ATTRIBUTE_NOTATION
} xmlAttributeType;




typedef enum {
    XML_ATTRIBUTE_NONE = 1,
    XML_ATTRIBUTE_REQUIRED,
    XML_ATTRIBUTE_IMPLIED,
    XML_ATTRIBUTE_FIXED
} xmlAttributeDefault;


typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;






struct _xmlEnumeration {

    struct _xmlEnumeration *next __attribute__((deprecated));

    const xmlChar *name __attribute__((deprecated));
};


typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;






struct _xmlAttribute {

    void *_private;

    xmlElementType type;

    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlDtd *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;

    struct _xmlDoc *doc;


    struct _xmlAttribute *nexth;

    xmlAttributeType atype;

    xmlAttributeDefault def;

    xmlChar *defaultValue;

    xmlEnumeration *tree __attribute__((deprecated));

    const xmlChar *prefix;

    const xmlChar *elem;
};




typedef enum {
    XML_ELEMENT_CONTENT_PCDATA = 1,
    XML_ELEMENT_CONTENT_ELEMENT,
    XML_ELEMENT_CONTENT_SEQ,
    XML_ELEMENT_CONTENT_OR
} xmlElementContentType;




typedef enum {
    XML_ELEMENT_CONTENT_ONCE = 1,
    XML_ELEMENT_CONTENT_OPT,
    XML_ELEMENT_CONTENT_MULT,
    XML_ELEMENT_CONTENT_PLUS
} xmlElementContentOccur;


typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;







struct _xmlElementContent {

    xmlElementContentType type __attribute__((deprecated));

    xmlElementContentOccur ocur __attribute__((deprecated));

    const xmlChar *name __attribute__((deprecated));

    struct _xmlElementContent *c1 __attribute__((deprecated));

    struct _xmlElementContent *c2 __attribute__((deprecated));

    struct _xmlElementContent *parent __attribute__((deprecated));

    const xmlChar *prefix __attribute__((deprecated));
};




typedef enum {
    XML_ELEMENT_TYPE_UNDEFINED = 0,
    XML_ELEMENT_TYPE_EMPTY = 1,
    XML_ELEMENT_TYPE_ANY,
    XML_ELEMENT_TYPE_MIXED,
    XML_ELEMENT_TYPE_ELEMENT
} xmlElementTypeVal;


typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;






struct _xmlElement {

    void *_private;

    xmlElementType type;

    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlDtd *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;

    struct _xmlDoc *doc;


    xmlElementTypeVal etype;

    xmlElementContent *content;

    xmlAttribute *attributes;

    const xmlChar *prefix;


    xmlRegexp *contModel __attribute__((deprecated));



};






typedef xmlElementType xmlNsType;


typedef struct _xmlNs xmlNs;
typedef xmlNs *xmlNsPtr;
# 519 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
struct _xmlNs {

    struct _xmlNs *next;

    xmlNsType type;

    const xmlChar *href;

    const xmlChar *prefix;

    void *_private;

    struct _xmlDoc *context __attribute__((deprecated));
};


typedef struct _xmlDtd xmlDtd;
typedef xmlDtd *xmlDtdPtr;







struct _xmlDtd {

    void *_private;

    xmlElementType type;

    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlDoc *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;

    struct _xmlDoc *doc;




    void *notations;

    void *elements;

    void *attributes;

    void *entities;

    xmlChar *ExternalID;

    xmlChar *SystemID;

    void *pentities;
};


typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;



struct _xmlAttr {

    void *_private;

    xmlElementType type;

    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlNode *parent;

    struct _xmlAttr *next;

    struct _xmlAttr *prev;

    struct _xmlDoc *doc;

    xmlNs *ns;

    xmlAttributeType atype;

    void *psvi;

    struct _xmlID *id __attribute__((deprecated));
};


typedef struct _xmlID xmlID;
typedef xmlID *xmlIDPtr;






struct _xmlID {

    struct _xmlID *next __attribute__((deprecated));

    xmlChar *value __attribute__((deprecated));

    xmlAttr *attr __attribute__((deprecated));

    const xmlChar *name __attribute__((deprecated));

    int lineno __attribute__((deprecated));

    struct _xmlDoc *doc __attribute__((deprecated));
};


typedef struct _xmlRef xmlRef;
typedef xmlRef *xmlRefPtr;



struct _xmlRef {

    struct _xmlRef *next __attribute__((deprecated));

    const xmlChar *value __attribute__((deprecated));

    xmlAttr *attr __attribute__((deprecated));

    const xmlChar *name __attribute__((deprecated));

    int lineno __attribute__((deprecated));
};



typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
# 695 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
struct _xmlNode {

    void *_private;

    xmlElementType type;
# 711 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlNode *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;







    struct _xmlDoc *doc;




    xmlNs *ns;






    xmlChar *content;





    struct _xmlAttr *properties;

    xmlNs *nsDef;

    void *psvi;

    unsigned short line;

    unsigned short extra;
};





typedef enum {

    XML_DOC_WELLFORMED = 1<<0,

    XML_DOC_NSVALID = 1<<1,

    XML_DOC_OLD10 = 1<<2,

    XML_DOC_DTDVALID = 1<<3,

    XML_DOC_XINCLUDE = 1<<4,

    XML_DOC_USERBUILT = 1<<5,

    XML_DOC_INTERNAL = 1<<6,

    XML_DOC_HTML = 1<<7
} xmlDocProperties;


typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;



struct _xmlDoc {

    void *_private;

    xmlElementType type;

    char *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlNode *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;

    struct _xmlDoc *doc;




    int compression;
# 820 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
    int standalone;

    struct _xmlDtd *intSubset;

    struct _xmlDtd *extSubset;

    struct _xmlNs *oldNs;

    xmlChar *version;

    xmlChar *encoding;

    void *ids;

    void *refs __attribute__((deprecated));

    xmlChar *URL;

    int charset;

    struct _xmlDict *dict;

    void *psvi;

    int parseFlags;

    int properties;
};



typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
# 863 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
typedef xmlNs *(*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxt *ctxt,
       xmlNode *node,
       const xmlChar *nsName,
       const xmlChar *nsPrefix);




struct _xmlDOMWrapCtxt {
    void * _private;




    int type;



    void * namespaceMap;




    xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
};






typedef void (*xmlRegisterNodeFunc) (xmlNode *node);






typedef void (*xmlDeregisterNodeFunc) (xmlNode *node);
# 925 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
__attribute__((deprecated))
          xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
__attribute__((deprecated))
          xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);
# 942 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h"
          int
  xmlValidateNCName (const xmlChar *value,
      int space);

          int
  xmlValidateQName (const xmlChar *value,
      int space);
          int
  xmlValidateName (const xmlChar *value,
      int space);
          int
  xmlValidateNMToken (const xmlChar *value,
      int space);

          xmlChar *
  xmlBuildQName (const xmlChar *ncname,
      const xmlChar *prefix,
      xmlChar *memory,
      int len);
          xmlChar *
  xmlSplitQName2 (const xmlChar *name,
      xmlChar **prefix);
          const xmlChar *
  xmlSplitQName3 (const xmlChar *name,
      int *len);




          xmlDtd *
  xmlCreateIntSubset (xmlDoc *doc,
      const xmlChar *name,
      const xmlChar *publicId,
      const xmlChar *systemId);
          xmlDtd *
  xmlNewDtd (xmlDoc *doc,
      const xmlChar *name,
      const xmlChar *publicId,
      const xmlChar *systemId);
          xmlDtd *
  xmlGetIntSubset (const xmlDoc *doc);
          void
  xmlFreeDtd (xmlDtd *cur);
          xmlNs *
  xmlNewNs (xmlNode *node,
      const xmlChar *href,
      const xmlChar *prefix);
          void
  xmlFreeNs (xmlNs *cur);
          void
  xmlFreeNsList (xmlNs *cur);
          xmlDoc *
  xmlNewDoc (const xmlChar *version);
          void
  xmlFreeDoc (xmlDoc *cur);
          xmlAttr *
  xmlNewDocProp (xmlDoc *doc,
      const xmlChar *name,
      const xmlChar *value);
          xmlAttr *
  xmlNewProp (xmlNode *node,
      const xmlChar *name,
      const xmlChar *value);
          xmlAttr *
  xmlNewNsProp (xmlNode *node,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *value);
          xmlAttr *
  xmlNewNsPropEatName (xmlNode *node,
      xmlNs *ns,
      xmlChar *name,
      const xmlChar *value);
          void
  xmlFreePropList (xmlAttr *cur);
          void
  xmlFreeProp (xmlAttr *cur);
          xmlAttr *
  xmlCopyProp (xmlNode *target,
      xmlAttr *cur);
          xmlAttr *
  xmlCopyPropList (xmlNode *target,
      xmlAttr *cur);
          xmlDtd *
  xmlCopyDtd (xmlDtd *dtd);
          xmlDoc *
  xmlCopyDoc (xmlDoc *doc,
      int recursive);



          xmlNode *
  xmlNewDocNode (xmlDoc *doc,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewDocNodeEatName (xmlDoc *doc,
      xmlNs *ns,
      xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewNode (xmlNs *ns,
      const xmlChar *name);
          xmlNode *
  xmlNewNodeEatName (xmlNs *ns,
      xmlChar *name);
          xmlNode *
  xmlNewChild (xmlNode *parent,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewDocText (const xmlDoc *doc,
      const xmlChar *content);
          xmlNode *
  xmlNewText (const xmlChar *content);
          xmlNode *
  xmlNewDocPI (xmlDoc *doc,
      const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewPI (const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewDocTextLen (xmlDoc *doc,
      const xmlChar *content,
      int len);
          xmlNode *
  xmlNewTextLen (const xmlChar *content,
      int len);
          xmlNode *
  xmlNewDocComment (xmlDoc *doc,
      const xmlChar *content);
          xmlNode *
  xmlNewComment (const xmlChar *content);
          xmlNode *
  xmlNewCDataBlock (xmlDoc *doc,
      const xmlChar *content,
      int len);
          xmlNode *
  xmlNewCharRef (xmlDoc *doc,
      const xmlChar *name);
          xmlNode *
  xmlNewReference (const xmlDoc *doc,
      const xmlChar *name);
          xmlNode *
  xmlCopyNode (xmlNode *node,
      int recursive);
          xmlNode *
  xmlDocCopyNode (xmlNode *node,
      xmlDoc *doc,
      int recursive);
          xmlNode *
  xmlDocCopyNodeList (xmlDoc *doc,
      xmlNode *node);
          xmlNode *
  xmlCopyNodeList (xmlNode *node);
          xmlNode *
  xmlNewTextChild (xmlNode *parent,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewDocRawNode (xmlDoc *doc,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *content);
          xmlNode *
  xmlNewDocFragment (xmlDoc *doc);




          long
  xmlGetLineNo (const xmlNode *node);
          xmlChar *
  xmlGetNodePath (const xmlNode *node);
          xmlNode *
  xmlDocGetRootElement (const xmlDoc *doc);
          xmlNode *
  xmlGetLastChild (const xmlNode *parent);
          int
  xmlNodeIsText (const xmlNode *node);
          int
  xmlIsBlankNode (const xmlNode *node);




          xmlNode *
  xmlDocSetRootElement (xmlDoc *doc,
      xmlNode *root);
          void
  xmlNodeSetName (xmlNode *cur,
      const xmlChar *name);
          xmlNode *
  xmlAddChild (xmlNode *parent,
      xmlNode *cur);
          xmlNode *
  xmlAddChildList (xmlNode *parent,
      xmlNode *cur);
          xmlNode *
  xmlReplaceNode (xmlNode *old,
      xmlNode *cur);
          xmlNode *
  xmlAddPrevSibling (xmlNode *cur,
      xmlNode *elem);
          xmlNode *
  xmlAddSibling (xmlNode *cur,
      xmlNode *elem);
          xmlNode *
  xmlAddNextSibling (xmlNode *cur,
      xmlNode *elem);
          void
  xmlUnlinkNode (xmlNode *cur);
          xmlNode *
  xmlTextMerge (xmlNode *first,
      xmlNode *second);
          int
  xmlTextConcat (xmlNode *node,
      const xmlChar *content,
      int len);
          void
  xmlFreeNodeList (xmlNode *cur);
          void
  xmlFreeNode (xmlNode *cur);
          int
  xmlSetTreeDoc (xmlNode *tree,
      xmlDoc *doc);
          int
  xmlSetListDoc (xmlNode *list,
      xmlDoc *doc);



          xmlNs *
  xmlSearchNs (xmlDoc *doc,
      xmlNode *node,
      const xmlChar *nameSpace);
          xmlNs *
  xmlSearchNsByHref (xmlDoc *doc,
      xmlNode *node,
      const xmlChar *href);
          int
  xmlGetNsListSafe (const xmlDoc *doc,
      const xmlNode *node,
      xmlNs ***out);
          xmlNs **
  xmlGetNsList (const xmlDoc *doc,
      const xmlNode *node);

          void
  xmlSetNs (xmlNode *node,
      xmlNs *ns);
          xmlNs *
  xmlCopyNamespace (xmlNs *cur);
          xmlNs *
  xmlCopyNamespaceList (xmlNs *cur);




          xmlAttr *
  xmlSetProp (xmlNode *node,
      const xmlChar *name,
      const xmlChar *value);
          xmlAttr *
  xmlSetNsProp (xmlNode *node,
      xmlNs *ns,
      const xmlChar *name,
      const xmlChar *value);
          int
  xmlNodeGetAttrValue (const xmlNode *node,
      const xmlChar *name,
      const xmlChar *nsUri,
      xmlChar **out);
          xmlChar *
  xmlGetNoNsProp (const xmlNode *node,
      const xmlChar *name);
          xmlChar *
  xmlGetProp (const xmlNode *node,
      const xmlChar *name);
          xmlAttr *
  xmlHasProp (const xmlNode *node,
      const xmlChar *name);
          xmlAttr *
  xmlHasNsProp (const xmlNode *node,
      const xmlChar *name,
      const xmlChar *nameSpace);
          xmlChar *
  xmlGetNsProp (const xmlNode *node,
      const xmlChar *name,
      const xmlChar *nameSpace);
          xmlNode *
  xmlStringGetNodeList (const xmlDoc *doc,
      const xmlChar *value);
          xmlNode *
  xmlStringLenGetNodeList (const xmlDoc *doc,
      const xmlChar *value,
      int len);
          xmlChar *
  xmlNodeListGetString (xmlDoc *doc,
      const xmlNode *list,
      int inLine);
          xmlChar *
  xmlNodeListGetRawString (const xmlDoc *doc,
      const xmlNode *list,
      int inLine);
          int
  xmlNodeSetContent (xmlNode *cur,
      const xmlChar *content);
          int
  xmlNodeSetContentLen (xmlNode *cur,
      const xmlChar *content,
      int len);
          int
  xmlNodeAddContent (xmlNode *cur,
      const xmlChar *content);
          int
  xmlNodeAddContentLen (xmlNode *cur,
      const xmlChar *content,
      int len);
          xmlChar *
  xmlNodeGetContent (const xmlNode *cur);

          int
  xmlNodeBufGetContent (xmlBuffer *buffer,
      const xmlNode *cur);
          int
  xmlBufGetNodeContent (xmlBuf *buf,
      const xmlNode *cur);

          xmlChar *
  xmlNodeGetLang (const xmlNode *cur);
          int
  xmlNodeGetSpacePreserve (const xmlNode *cur);
          int
  xmlNodeSetLang (xmlNode *cur,
      const xmlChar *lang);
          int
  xmlNodeSetSpacePreserve (xmlNode *cur,
      int val);
          int
  xmlNodeGetBaseSafe (const xmlDoc *doc,
      const xmlNode *cur,
      xmlChar **baseOut);
          xmlChar *
  xmlNodeGetBase (const xmlDoc *doc,
      const xmlNode *cur);
          int
  xmlNodeSetBase (xmlNode *cur,
      const xmlChar *uri);




          int
  xmlRemoveProp (xmlAttr *cur);
          int
  xmlUnsetNsProp (xmlNode *node,
      xmlNs *ns,
      const xmlChar *name);
          int
  xmlUnsetProp (xmlNode *node,
      const xmlChar *name);


          void xmlAttrSerializeTxtContent(xmlBuffer *buf,
      xmlDoc *doc,
      xmlAttr *attr,
      const xmlChar *string);





          int
  xmlReconciliateNs (xmlDoc *doc,
      xmlNode *tree);





          void
  xmlDocDumpFormatMemory (xmlDoc *cur,
      xmlChar **mem,
      int *size,
      int format);
          void
  xmlDocDumpMemory (xmlDoc *cur,
      xmlChar **mem,
      int *size);
          void
  xmlDocDumpMemoryEnc (xmlDoc *out_doc,
      xmlChar **doc_txt_ptr,
      int * doc_txt_len,
      const char *txt_encoding);
          void
  xmlDocDumpFormatMemoryEnc(xmlDoc *out_doc,
      xmlChar **doc_txt_ptr,
      int * doc_txt_len,
      const char *txt_encoding,
      int format);
          int
  xmlDocFormatDump (FILE *f,
      xmlDoc *cur,
      int format);
          int
  xmlDocDump (FILE *f,
      xmlDoc *cur);
          void
  xmlElemDump (FILE *f,
      xmlDoc *doc,
      xmlNode *cur);
          int
  xmlSaveFile (const char *filename,
      xmlDoc *cur);
          int
  xmlSaveFormatFile (const char *filename,
      xmlDoc *cur,
      int format);
          size_t
  xmlBufNodeDump (xmlBuf *buf,
      xmlDoc *doc,
      xmlNode *cur,
      int level,
      int format);
          int
  xmlNodeDump (xmlBuffer *buf,
      xmlDoc *doc,
      xmlNode *cur,
      int level,
      int format);

          int
  xmlSaveFileTo (xmlOutputBuffer *buf,
      xmlDoc *cur,
      const char *encoding);
          int
  xmlSaveFormatFileTo (xmlOutputBuffer *buf,
      xmlDoc *cur,
             const char *encoding,
             int format);
          void
  xmlNodeDumpOutput (xmlOutputBuffer *buf,
      xmlDoc *doc,
      xmlNode *cur,
      int level,
      int format,
      const char *encoding);

          int
  xmlSaveFormatFileEnc (const char *filename,
      xmlDoc *cur,
      const char *encoding,
      int format);

          int
  xmlSaveFileEnc (const char *filename,
      xmlDoc *cur,
      const char *encoding);





          int
  xmlIsXHTML (const xmlChar *systemID,
      const xmlChar *publicID);




          int
  xmlGetDocCompressMode (const xmlDoc *doc);
          void
  xmlSetDocCompressMode (xmlDoc *doc,
      int mode);
__attribute__((deprecated))
          int
  xmlGetCompressMode (void);
__attribute__((deprecated))
          void
  xmlSetCompressMode (int mode);




          xmlDOMWrapCtxt *
  xmlDOMWrapNewCtxt (void);
          void
  xmlDOMWrapFreeCtxt (xmlDOMWrapCtxt *ctxt);
          int
     xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxt *ctxt,
      xmlNode *elem,
      int options);
          int
     xmlDOMWrapAdoptNode (xmlDOMWrapCtxt *ctxt,
      xmlDoc *sourceDoc,
      xmlNode *node,
      xmlDoc *destDoc,
      xmlNode *destParent,
      int options);
          int
     xmlDOMWrapRemoveNode (xmlDOMWrapCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *node,
      int options);
          int
     xmlDOMWrapCloneNode (xmlDOMWrapCtxt *ctxt,
      xmlDoc *sourceDoc,
      xmlNode *node,
      xmlNode **clonedNode,
      xmlDoc *destDoc,
      xmlNode *destParent,
      int deep,
      int options);





          unsigned long
            xmlChildElementCount (xmlNode *parent);
          xmlNode *
            xmlNextElementSibling (xmlNode *node);
          xmlNode *
            xmlFirstElementChild (xmlNode *parent);
          xmlNode *
            xmlLastElementChild (xmlNode *parent);
          xmlNode *
            xmlPreviousElementSibling (xmlNode *node);

__attribute__((deprecated))
          xmlRegisterNodeFunc
     xmlRegisterNodeDefault (xmlRegisterNodeFunc func);
__attribute__((deprecated))
          xmlDeregisterNodeFunc
     xmlDeregisterNodeDefault (xmlDeregisterNodeFunc func);
__attribute__((deprecated))
          xmlRegisterNodeFunc
            xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
__attribute__((deprecated))
          xmlDeregisterNodeFunc
            xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);





__attribute__((deprecated))
          void
  xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
__attribute__((deprecated))
          xmlBufferAllocationScheme
  xmlGetBufferAllocationScheme(void);

          xmlBuffer *
  xmlBufferCreate (void);
          xmlBuffer *
  xmlBufferCreateSize (size_t size);
          xmlBuffer *
  xmlBufferCreateStatic (void *mem,
      size_t size);
__attribute__((deprecated))
          int
  xmlBufferResize (xmlBuffer *buf,
      unsigned int size);
          void
  xmlBufferFree (xmlBuffer *buf);
          int
  xmlBufferDump (FILE *file,
      xmlBuffer *buf);
          int
  xmlBufferAdd (xmlBuffer *buf,
      const xmlChar *str,
      int len);
          int
  xmlBufferAddHead (xmlBuffer *buf,
      const xmlChar *str,
      int len);
          int
  xmlBufferCat (xmlBuffer *buf,
      const xmlChar *str);
          int
  xmlBufferCCat (xmlBuffer *buf,
      const char *str);
__attribute__((deprecated))
          int
  xmlBufferShrink (xmlBuffer *buf,
      unsigned int len);
__attribute__((deprecated))
          int
  xmlBufferGrow (xmlBuffer *buf,
      unsigned int len);
          void
  xmlBufferEmpty (xmlBuffer *buf);
          const xmlChar*
  xmlBufferContent (const xmlBuffer *buf);
          xmlChar*
  xmlBufferDetach (xmlBuffer *buf);
          void
  xmlBufferSetAllocationScheme(xmlBuffer *buf,
      xmlBufferAllocationScheme scheme);
          int
  xmlBufferLength (const xmlBuffer *buf);
          void
  xmlBufferWriteCHAR (xmlBuffer *buf,
      const xmlChar *string);
          void
  xmlBufferWriteChar (xmlBuffer *buf,
      const char *string);
          void
  xmlBufferWriteQuotedString(xmlBuffer *buf,
      const xmlChar *string);





          xmlChar* xmlBufContent (const xmlBuf* buf);
          xmlChar* xmlBufEnd (xmlBuf *buf);
          size_t xmlBufUse (xmlBuf *buf);
          size_t xmlBufShrink (xmlBuf *buf, size_t len);


}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/dict.h" 1
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/dict.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 1 3
# 88 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 89 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 94 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_wchar_t.h" 1 3
# 104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_null.h" 1 3
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_nullptr_t.h" 1 3
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 128 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/__stddef_offsetof.h" 1 3
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stddef.h" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/dict.h" 2




extern "C" {





typedef struct _xmlDict xmlDict;
typedef xmlDict *xmlDictPtr;




__attribute__((deprecated))
          int xmlInitializeDict(void);




          xmlDict *
   xmlDictCreate (void);
          size_t
   xmlDictSetLimit (xmlDict *dict,
                                         size_t limit);
          size_t
   xmlDictGetUsage (xmlDict *dict);
          xmlDict *
   xmlDictCreateSub(xmlDict *sub);
          int
   xmlDictReference(xmlDict *dict);
          void
   xmlDictFree (xmlDict *dict);




          const xmlChar *
   xmlDictLookup (xmlDict *dict,
                           const xmlChar *name,
                           int len);
          const xmlChar *
   xmlDictExists (xmlDict *dict,
                           const xmlChar *name,
                           int len);
          const xmlChar *
   xmlDictQLookup (xmlDict *dict,
                           const xmlChar *prefix,
                           const xmlChar *name);
          int
   xmlDictOwns (xmlDict *dict,
      const xmlChar *str);
          int
   xmlDictSize (xmlDict *dict);




__attribute__((deprecated))
          void
                        xmlDictCleanup (void);


}
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/hash.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/hash.h"
extern "C" {







typedef struct _xmlHashTable xmlHashTable;
typedef xmlHashTable *xmlHashTablePtr;
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/hash.h"
typedef void (*xmlHashDeallocator)(void *payload, const xmlChar *name);







typedef void *(*xmlHashCopier)(void *payload, const xmlChar *name);







typedef void (*xmlHashScanner)(void *payload, void *data, const xmlChar *name);
# 87 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/hash.h"
typedef void (*xmlHashScannerFull)(void *payload, void *data,
       const xmlChar *name, const xmlChar *name2,
       const xmlChar *name3);




          xmlHashTable *
  xmlHashCreate (int size);
          xmlHashTable *
  xmlHashCreateDict (int size,
      xmlDict *dict);
          void
  xmlHashFree (xmlHashTable *hash,
      xmlHashDeallocator dealloc);
          void
  xmlHashDefaultDeallocator(void *entry,
      const xmlChar *name);




          int
  xmlHashAdd (xmlHashTable *hash,
                           const xmlChar *name,
                           void *userdata);
          int
  xmlHashAddEntry (xmlHashTable *hash,
                           const xmlChar *name,
                           void *userdata);
          int
  xmlHashUpdateEntry (xmlHashTable *hash,
                           const xmlChar *name,
                           void *userdata,
      xmlHashDeallocator dealloc);
          int
  xmlHashAdd2 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           void *userdata);
          int
  xmlHashAddEntry2 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           void *userdata);
          int
  xmlHashUpdateEntry2 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           void *userdata,
      xmlHashDeallocator dealloc);
          int
  xmlHashAdd3 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           const xmlChar *name3,
                           void *userdata);
          int
  xmlHashAddEntry3 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           const xmlChar *name3,
                           void *userdata);
          int
  xmlHashUpdateEntry3 (xmlHashTable *hash,
                           const xmlChar *name,
                           const xmlChar *name2,
                           const xmlChar *name3,
                           void *userdata,
      xmlHashDeallocator dealloc);




          int
  xmlHashRemoveEntry (xmlHashTable *hash,
      const xmlChar *name,
      xmlHashDeallocator dealloc);
          int
  xmlHashRemoveEntry2 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2,
      xmlHashDeallocator dealloc);
          int
  xmlHashRemoveEntry3 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2,
      const xmlChar *name3,
      xmlHashDeallocator dealloc);




          void *
  xmlHashLookup (xmlHashTable *hash,
      const xmlChar *name);
          void *
  xmlHashLookup2 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2);
          void *
  xmlHashLookup3 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2,
      const xmlChar *name3);
          void *
  xmlHashQLookup (xmlHashTable *hash,
      const xmlChar *prefix,
      const xmlChar *name);
          void *
  xmlHashQLookup2 (xmlHashTable *hash,
      const xmlChar *prefix,
      const xmlChar *name,
      const xmlChar *prefix2,
      const xmlChar *name2);
          void *
  xmlHashQLookup3 (xmlHashTable *hash,
      const xmlChar *prefix,
      const xmlChar *name,
      const xmlChar *prefix2,
      const xmlChar *name2,
      const xmlChar *prefix3,
      const xmlChar *name3);




          xmlHashTable *
  xmlHashCopySafe (xmlHashTable *hash,
      xmlHashCopier copy,
      xmlHashDeallocator dealloc);
          xmlHashTable *
  xmlHashCopy (xmlHashTable *hash,
      xmlHashCopier copy);
          int
  xmlHashSize (xmlHashTable *hash);
          void
  xmlHashScan (xmlHashTable *hash,
      xmlHashScanner scan,
      void *data);
          void
  xmlHashScan3 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2,
      const xmlChar *name3,
      xmlHashScanner scan,
      void *data);
          void
  xmlHashScanFull (xmlHashTable *hash,
      xmlHashScannerFull scan,
      void *data);
          void
  xmlHashScanFull3 (xmlHashTable *hash,
      const xmlChar *name,
      const xmlChar *name2,
      const xmlChar *name3,
      xmlHashScannerFull scan,
      void *data);

}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h" 1
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 1
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/list.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/list.h"
extern "C" {







typedef struct _xmlLink xmlLink;
typedef xmlLink *xmlLinkPtr;






typedef struct _xmlList xmlList;
typedef xmlList *xmlListPtr;






typedef void (*xmlListDeallocator) (xmlLink *lk);







typedef int (*xmlListDataCompare) (const void *data0, const void *data1);







typedef int (*xmlListWalker) (const void *data, void *user);


          xmlList *
  xmlListCreate (xmlListDeallocator deallocator,
                                  xmlListDataCompare compare);
          void
  xmlListDelete (xmlList *l);


          void *
  xmlListSearch (xmlList *l,
      void *data);
          void *
  xmlListReverseSearch (xmlList *l,
      void *data);
          int
  xmlListInsert (xmlList *l,
      void *data) ;
          int
  xmlListAppend (xmlList *l,
      void *data) ;
          int
  xmlListRemoveFirst (xmlList *l,
      void *data);
          int
  xmlListRemoveLast (xmlList *l,
      void *data);
          int
  xmlListRemoveAll (xmlList *l,
      void *data);
          void
  xmlListClear (xmlList *l);
          int
  xmlListEmpty (xmlList *l);
          xmlLink *
  xmlListFront (xmlList *l);
          xmlLink *
  xmlListEnd (xmlList *l);
          int
  xmlListSize (xmlList *l);

          void
  xmlListPopFront (xmlList *l);
          void
  xmlListPopBack (xmlList *l);
          int
  xmlListPushFront (xmlList *l,
      void *data);
          int
  xmlListPushBack (xmlList *l,
      void *data);


          void
  xmlListReverse (xmlList *l);
          void
  xmlListSort (xmlList *l);
          void
  xmlListWalk (xmlList *l,
      xmlListWalker walker,
      void *user);
          void
  xmlListReverseWalk (xmlList *l,
      xmlListWalker walker,
      void *user);
          void
  xmlListMerge (xmlList *l1,
      xmlList *l2);
          xmlList *
  xmlListDup (xmlList *old);
          int
  xmlListCopy (xmlList *cur,
      xmlList *old);

          void *
  xmlLinkGetData (xmlLink *lk);





}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlautomata.h" 1
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlautomata.h"
extern "C" {







typedef struct _xmlAutomata xmlAutomata;
typedef xmlAutomata *xmlAutomataPtr;




typedef struct _xmlAutomataState xmlAutomataState;
typedef xmlAutomataState *xmlAutomataStatePtr;




__attribute__((deprecated))
          xmlAutomata *
      xmlNewAutomata (void);
__attribute__((deprecated))
          void
      xmlFreeAutomata (xmlAutomata *am);

__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataGetInitState (xmlAutomata *am);
__attribute__((deprecated))
          int
      xmlAutomataSetFinalState (xmlAutomata *am,
       xmlAutomataState *state);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewState (xmlAutomata *am);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewTransition (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewTransition2 (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       const xmlChar *token2,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
                    xmlAutomataNewNegTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       const xmlChar *token2,
       void *data);

__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewCountTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       int min,
       int max,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewCountTrans2 (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       const xmlChar *token2,
       int min,
       int max,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewOnceTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       int min,
       int max,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewOnceTrans2 (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       const xmlChar *token,
       const xmlChar *token2,
       int min,
       int max,
       void *data);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewAllTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       int lax);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewEpsilon (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewCountedTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       int counter);
__attribute__((deprecated))
          xmlAutomataState *
      xmlAutomataNewCounterTrans (xmlAutomata *am,
       xmlAutomataState *from,
       xmlAutomataState *to,
       int counter);
__attribute__((deprecated))
          int
      xmlAutomataNewCounter (xmlAutomata *am,
       int min,
       int max);

__attribute__((deprecated))
          struct _xmlRegexp *
      xmlAutomataCompile (xmlAutomata *am);
__attribute__((deprecated))
          int
      xmlAutomataIsDeterminist (xmlAutomata *am);


}
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h" 2



extern "C" {





typedef struct _xmlValidState xmlValidState;
typedef xmlValidState *xmlValidStatePtr;
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h"
typedef void (*xmlValidityErrorFunc) (void *ctx,
        const char *msg,
        ...) __attribute__((__format__(__printf__,2,3)));
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/valid.h"
typedef void (*xmlValidityWarningFunc) (void *ctx,
          const char *msg,
          ...) __attribute__((__format__(__printf__,2,3)));

typedef struct _xmlValidCtxt xmlValidCtxt;
typedef xmlValidCtxt *xmlValidCtxtPtr;



struct _xmlValidCtxt {
    void *userData;
    xmlValidityErrorFunc error;
    xmlValidityWarningFunc warning;


    xmlNode *node;
    int nodeNr;
    int nodeMax;
    xmlNode **nodeTab;

    unsigned int flags;
    xmlDoc *doc;
    int valid;


    xmlValidState *vstate;
    int vstateNr;
    int vstateMax;
    xmlValidState *vstateTab;


    xmlAutomata *am;
    xmlAutomataState *state;




};

typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;

typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;

typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;

typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;

typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;


          xmlNotation *
  xmlAddNotationDecl (xmlValidCtxt *ctxt,
      xmlDtd *dtd,
      const xmlChar *name,
      const xmlChar *publicId,
      const xmlChar *systemId);
__attribute__((deprecated))
          xmlNotationTable *
  xmlCopyNotationTable (xmlNotationTable *table);
__attribute__((deprecated))
          void
  xmlFreeNotationTable (xmlNotationTable *table);

__attribute__((deprecated))
          void
  xmlDumpNotationDecl (xmlBuffer *buf,
      xmlNotation *nota);

          void
  xmlDumpNotationTable (xmlBuffer *buf,
      xmlNotationTable *table);



__attribute__((deprecated))
          xmlElementContent *
  xmlNewElementContent (const xmlChar *name,
      xmlElementContentType type);
__attribute__((deprecated))
          xmlElementContent *
  xmlCopyElementContent (xmlElementContent *content);
__attribute__((deprecated))
          void
  xmlFreeElementContent (xmlElementContent *cur);
__attribute__((deprecated))
          xmlElementContent *
  xmlNewDocElementContent (xmlDoc *doc,
      const xmlChar *name,
      xmlElementContentType type);
__attribute__((deprecated))
          xmlElementContent *
  xmlCopyDocElementContent(xmlDoc *doc,
      xmlElementContent *content);
__attribute__((deprecated))
          void
  xmlFreeDocElementContent(xmlDoc *doc,
      xmlElementContent *cur);
__attribute__((deprecated))
          void
  xmlSnprintfElementContent(char *buf,
      int size,
                                  xmlElementContent *content,
      int englob);

__attribute__((deprecated))
          void
  xmlSprintfElementContent(char *buf,
                                  xmlElementContent *content,
      int englob);



          xmlElement *
  xmlAddElementDecl (xmlValidCtxt *ctxt,
      xmlDtd *dtd,
      const xmlChar *name,
      xmlElementTypeVal type,
      xmlElementContent *content);
__attribute__((deprecated))
          xmlElementTable *
  xmlCopyElementTable (xmlElementTable *table);
__attribute__((deprecated))
          void
  xmlFreeElementTable (xmlElementTable *table);

__attribute__((deprecated))
          void
  xmlDumpElementTable (xmlBuffer *buf,
      xmlElementTable *table);
__attribute__((deprecated))
          void
  xmlDumpElementDecl (xmlBuffer *buf,
      xmlElement *elem);



__attribute__((deprecated))
          xmlEnumeration *
  xmlCreateEnumeration (const xmlChar *name);

          void
  xmlFreeEnumeration (xmlEnumeration *cur);
__attribute__((deprecated))
          xmlEnumeration *
  xmlCopyEnumeration (xmlEnumeration *cur);


          xmlAttribute *
  xmlAddAttributeDecl (xmlValidCtxt *ctxt,
      xmlDtd *dtd,
      const xmlChar *elem,
      const xmlChar *name,
      const xmlChar *ns,
      xmlAttributeType type,
      xmlAttributeDefault def,
      const xmlChar *defaultValue,
      xmlEnumeration *tree);
__attribute__((deprecated))
          xmlAttributeTable *
  xmlCopyAttributeTable (xmlAttributeTable *table);
__attribute__((deprecated))
          void
  xmlFreeAttributeTable (xmlAttributeTable *table);

__attribute__((deprecated))
          void
  xmlDumpAttributeTable (xmlBuffer *buf,
     xmlAttributeTable *table);
__attribute__((deprecated))
          void
  xmlDumpAttributeDecl (xmlBuffer *buf,
     xmlAttribute *attr);



          int
  xmlAddIDSafe (xmlAttr *attr,
     const xmlChar *value);
          xmlID *
  xmlAddID (xmlValidCtxt *ctxt,
     xmlDoc *doc,
     const xmlChar *value,
     xmlAttr *attr);
          void
  xmlFreeIDTable (xmlIDTable *table);
          xmlAttr *
  xmlGetID (xmlDoc *doc,
     const xmlChar *ID);
          int
  xmlIsID (xmlDoc *doc,
     xmlNode *elem,
     xmlAttr *attr);
          int
  xmlRemoveID (xmlDoc *doc,
     xmlAttr *attr);


__attribute__((deprecated))
          xmlRef *
  xmlAddRef (xmlValidCtxt *ctxt,
     xmlDoc *doc,
     const xmlChar *value,
     xmlAttr *attr);
__attribute__((deprecated))
          void
  xmlFreeRefTable (xmlRefTable *table);
__attribute__((deprecated))
          int
  xmlIsRef (xmlDoc *doc,
     xmlNode *elem,
     xmlAttr *attr);
__attribute__((deprecated))
          int
  xmlRemoveRef (xmlDoc *doc,
     xmlAttr *attr);
__attribute__((deprecated))
          xmlList *
  xmlGetRefs (xmlDoc *doc,
     const xmlChar *ID);






          xmlValidCtxt *
  xmlNewValidCtxt(void);
          void
  xmlFreeValidCtxt(xmlValidCtxt *);

__attribute__((deprecated))
          int
  xmlValidateRoot (xmlValidCtxt *ctxt,
      xmlDoc *doc);
__attribute__((deprecated))
          int
  xmlValidateElementDecl (xmlValidCtxt *ctxt,
      xmlDoc *doc,
                           xmlElement *elem);
__attribute__((deprecated))
          xmlChar *
  xmlValidNormalizeAttributeValue(xmlDoc *doc,
      xmlNode *elem,
      const xmlChar *name,
      const xmlChar *value);
__attribute__((deprecated))
          xmlChar *
  xmlValidCtxtNormalizeAttributeValue(xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem,
      const xmlChar *name,
      const xmlChar *value);
__attribute__((deprecated))
          int
  xmlValidateAttributeDecl(xmlValidCtxt *ctxt,
      xmlDoc *doc,
                           xmlAttribute *attr);
__attribute__((deprecated))
          int
  xmlValidateAttributeValue(xmlAttributeType type,
      const xmlChar *value);
__attribute__((deprecated))
          int
  xmlValidateNotationDecl (xmlValidCtxt *ctxt,
      xmlDoc *doc,
                           xmlNotation *nota);
          int
  xmlValidateDtd (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlDtd *dtd);
__attribute__((deprecated))
          int
  xmlValidateDtdFinal (xmlValidCtxt *ctxt,
      xmlDoc *doc);
          int
  xmlValidateDocument (xmlValidCtxt *ctxt,
      xmlDoc *doc);
          int
  xmlValidateElement (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem);
__attribute__((deprecated))
          int
  xmlValidateOneElement (xmlValidCtxt *ctxt,
      xmlDoc *doc,
                           xmlNode *elem);
__attribute__((deprecated))
          int
  xmlValidateOneAttribute (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem,
      xmlAttr *attr,
      const xmlChar *value);
__attribute__((deprecated))
          int
  xmlValidateOneNamespace (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem,
      const xmlChar *prefix,
      xmlNs *ns,
      const xmlChar *value);
__attribute__((deprecated))
          int
  xmlValidateDocumentFinal(xmlValidCtxt *ctxt,
      xmlDoc *doc);
__attribute__((deprecated))
          int
  xmlValidateNotationUse (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      const xmlChar *notationName);


__attribute__((deprecated))
          int
  xmlIsMixedElement (xmlDoc *doc,
      const xmlChar *name);
          xmlAttribute *
  xmlGetDtdAttrDesc (xmlDtd *dtd,
      const xmlChar *elem,
      const xmlChar *name);
          xmlAttribute *
  xmlGetDtdQAttrDesc (xmlDtd *dtd,
      const xmlChar *elem,
      const xmlChar *name,
      const xmlChar *prefix);
          xmlNotation *
  xmlGetDtdNotationDesc (xmlDtd *dtd,
      const xmlChar *name);
          xmlElement *
  xmlGetDtdQElementDesc (xmlDtd *dtd,
      const xmlChar *name,
      const xmlChar *prefix);
          xmlElement *
  xmlGetDtdElementDesc (xmlDtd *dtd,
      const xmlChar *name);



          int
  xmlValidGetPotentialChildren(xmlElementContent *ctree,
      const xmlChar **names,
      int *len,
      int max);


          int
  xmlValidGetValidElements(xmlNode *prev,
      xmlNode *next,
      const xmlChar **names,
      int max);
          int
  xmlValidateNameValue (const xmlChar *value);
          int
  xmlValidateNamesValue (const xmlChar *value);
          int
  xmlValidateNmtokenValue (const xmlChar *value);
          int
  xmlValidateNmtokensValue(const xmlChar *value);





__attribute__((deprecated))
          int
  xmlValidBuildContentModel(xmlValidCtxt *ctxt,
      xmlElement *elem);

__attribute__((deprecated))
          int
  xmlValidatePushElement (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem,
      const xmlChar *qname);
__attribute__((deprecated))
          int
  xmlValidatePushCData (xmlValidCtxt *ctxt,
      const xmlChar *data,
      int len);
__attribute__((deprecated))
          int
  xmlValidatePopElement (xmlValidCtxt *ctxt,
      xmlDoc *doc,
      xmlNode *elem,
      const xmlChar *qname);





}
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/entities.h" 1
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/entities.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 1
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/entities.h" 2



extern "C" {





typedef enum {

    XML_INTERNAL_GENERAL_ENTITY = 1,

    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,

    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,

    XML_INTERNAL_PARAMETER_ENTITY = 4,

    XML_EXTERNAL_PARAMETER_ENTITY = 5,

    XML_INTERNAL_PREDEFINED_ENTITY = 6
} xmlEntityType;




struct _xmlEntity {

    void *_private;

    xmlElementType type;

    const xmlChar *name;

    struct _xmlNode *children;

    struct _xmlNode *last;

    struct _xmlDtd *parent;

    struct _xmlNode *next;

    struct _xmlNode *prev;

    struct _xmlDoc *doc;


    xmlChar *orig;

    xmlChar *content;

    int length;

    xmlEntityType etype;

    const xmlChar *ExternalID;

    const xmlChar *SystemID;


    struct _xmlEntity *nexte;

    const xmlChar *URI;

    int owner;

    int flags;

    unsigned long expandedSize;
};

typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;

          xmlEntity *
   xmlNewEntity (xmlDoc *doc,
       const xmlChar *name,
       int type,
       const xmlChar *publicId,
       const xmlChar *systemId,
       const xmlChar *content);
          void
   xmlFreeEntity (xmlEntity *entity);
          int
   xmlAddEntity (xmlDoc *doc,
       int extSubset,
       const xmlChar *name,
       int type,
       const xmlChar *publicId,
       const xmlChar *systemId,
       const xmlChar *content,
       xmlEntity **out);
          xmlEntity *
   xmlAddDocEntity (xmlDoc *doc,
       const xmlChar *name,
       int type,
       const xmlChar *publicId,
       const xmlChar *systemId,
       const xmlChar *content);
          xmlEntity *
   xmlAddDtdEntity (xmlDoc *doc,
       const xmlChar *name,
       int type,
       const xmlChar *publicId,
       const xmlChar *systemId,
       const xmlChar *content);
          xmlEntity *
   xmlGetPredefinedEntity (const xmlChar *name);
          xmlEntity *
   xmlGetDocEntity (const xmlDoc *doc,
       const xmlChar *name);
          xmlEntity *
   xmlGetDtdEntity (xmlDoc *doc,
       const xmlChar *name);
          xmlEntity *
   xmlGetParameterEntity (xmlDoc *doc,
       const xmlChar *name);
          xmlChar *
   xmlEncodeEntitiesReentrant(xmlDoc *doc,
       const xmlChar *input);
          xmlChar *
   xmlEncodeSpecialChars (const xmlDoc *doc,
       const xmlChar *input);
__attribute__((deprecated))
          xmlEntitiesTable *
   xmlCreateEntitiesTable (void);
__attribute__((deprecated))
          xmlEntitiesTable *
   xmlCopyEntitiesTable (xmlEntitiesTable *table);
__attribute__((deprecated))
          void
   xmlFreeEntitiesTable (xmlEntitiesTable *table);

__attribute__((deprecated))
          void
   xmlDumpEntitiesTable (xmlBuffer *buf,
       xmlEntitiesTable *table);
__attribute__((deprecated))
          void
   xmlDumpEntityDecl (xmlBuffer *buf,
       xmlEntity *ent);



}
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h" 1
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
extern "C" {
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
typedef enum {

    XML_ENC_ERR_SUCCESS = 0,

    XML_ENC_ERR_INTERNAL = -1,

    XML_ENC_ERR_INPUT = -2,

    XML_ENC_ERR_SPACE = -3,

    XML_ENC_ERR_MEMORY = -4
} xmlCharEncError;




typedef enum {

    XML_CHAR_ENCODING_ERROR= -1,

    XML_CHAR_ENCODING_NONE= 0,

    XML_CHAR_ENCODING_UTF8= 1,

    XML_CHAR_ENCODING_UTF16LE= 2,

    XML_CHAR_ENCODING_UTF16BE= 3,

    XML_CHAR_ENCODING_UCS4LE= 4,

    XML_CHAR_ENCODING_UCS4BE= 5,

    XML_CHAR_ENCODING_EBCDIC= 6,

    XML_CHAR_ENCODING_UCS4_2143=7,

    XML_CHAR_ENCODING_UCS4_3412=8,

    XML_CHAR_ENCODING_UCS2= 9,

    XML_CHAR_ENCODING_8859_1= 10,

    XML_CHAR_ENCODING_8859_2= 11,

    XML_CHAR_ENCODING_8859_3= 12,

    XML_CHAR_ENCODING_8859_4= 13,

    XML_CHAR_ENCODING_8859_5= 14,

    XML_CHAR_ENCODING_8859_6= 15,

    XML_CHAR_ENCODING_8859_7= 16,

    XML_CHAR_ENCODING_8859_8= 17,

    XML_CHAR_ENCODING_8859_9= 18,

    XML_CHAR_ENCODING_2022_JP= 19,

    XML_CHAR_ENCODING_SHIFT_JIS=20,

    XML_CHAR_ENCODING_EUC_JP= 21,

    XML_CHAR_ENCODING_ASCII= 22,

    XML_CHAR_ENCODING_UTF16= 23,

    XML_CHAR_ENCODING_HTML= 24,

    XML_CHAR_ENCODING_8859_10= 25,

    XML_CHAR_ENCODING_8859_11= 26,

    XML_CHAR_ENCODING_8859_13= 27,

    XML_CHAR_ENCODING_8859_14= 28,

    XML_CHAR_ENCODING_8859_15= 29,

    XML_CHAR_ENCODING_8859_16= 30,

    XML_CHAR_ENCODING_WINDOWS_1252 = 31
} xmlCharEncoding;




typedef enum {

    XML_ENC_INPUT = (1 << 0),

    XML_ENC_OUTPUT = (1 << 1),

    XML_ENC_HTML = (1 << 2)
} xmlCharEncFlags;
# 141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
typedef int (*xmlCharEncodingInputFunc)(unsigned char *out, int *outlen,
                                        const unsigned char *in, int *inlen);
# 157 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
typedef int (*xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen,
                                         const unsigned char *in, int *inlen);
# 179 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
typedef xmlCharEncError
(*xmlCharEncConvFunc)(void *vctxt, unsigned char *out, int *outlen,
                      const unsigned char *in, int *inlen, int flush);






typedef void
(*xmlCharEncConvCtxtDtor)(void *vctxt);


typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler;
typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;





struct _xmlCharEncodingHandler {
    char *name __attribute__((deprecated));
    union {
        xmlCharEncConvFunc func;
        xmlCharEncodingInputFunc legacyFunc;
    } input __attribute__((deprecated));
    union {
        xmlCharEncConvFunc func;
        xmlCharEncodingOutputFunc legacyFunc;
    } output __attribute__((deprecated));
    void *inputCtxt __attribute__((deprecated));
    void *outputCtxt __attribute__((deprecated));
    xmlCharEncConvCtxtDtor ctxtDtor __attribute__((deprecated));
    int flags __attribute__((deprecated));
};
# 228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/encoding.h"
typedef xmlParserErrors
(*xmlCharEncConvImpl)(void *vctxt, const char *name, xmlCharEncFlags flags,
                      xmlCharEncodingHandler **out);




__attribute__((deprecated))
          void
 xmlInitCharEncodingHandlers (void);
__attribute__((deprecated))
          void
 xmlCleanupCharEncodingHandlers (void);
__attribute__((deprecated))
          void
 xmlRegisterCharEncodingHandler (xmlCharEncodingHandler *handler);
          xmlParserErrors
 xmlLookupCharEncodingHandler (xmlCharEncoding enc,
      xmlCharEncodingHandler **out);
          xmlParserErrors
 xmlOpenCharEncodingHandler (const char *name,
      int output,
      xmlCharEncodingHandler **out);
          xmlParserErrors
 xmlCreateCharEncodingHandler (const char *name,
      xmlCharEncFlags flags,
      xmlCharEncConvImpl impl,
      void *implCtxt,
      xmlCharEncodingHandler **out);
          xmlCharEncodingHandler *
 xmlGetCharEncodingHandler (xmlCharEncoding enc);
          xmlCharEncodingHandler *
 xmlFindCharEncodingHandler (const char *name);
__attribute__((deprecated))
          xmlCharEncodingHandler *
 xmlNewCharEncodingHandler (const char *name,
      xmlCharEncodingInputFunc input,
      xmlCharEncodingOutputFunc output);
          xmlParserErrors
 xmlCharEncNewCustomHandler (const char *name,
      xmlCharEncConvFunc input,
      xmlCharEncConvFunc output,
      xmlCharEncConvCtxtDtor ctxtDtor,
      void *inputCtxt,
      void *outputCtxt,
      xmlCharEncodingHandler **out);




__attribute__((deprecated))
          int
 xmlAddEncodingAlias (const char *name,
      const char *alias);
__attribute__((deprecated))
          int
 xmlDelEncodingAlias (const char *alias);
__attribute__((deprecated))
          const char *
 xmlGetEncodingAlias (const char *alias);
__attribute__((deprecated))
          void
 xmlCleanupEncodingAliases (void);
          xmlCharEncoding
 xmlParseCharEncoding (const char *name);
          const char *
 xmlGetCharEncodingName (xmlCharEncoding enc);




          xmlCharEncoding
 xmlDetectCharEncoding (const unsigned char *in,
      int len);

struct _xmlBuffer;
          int
 xmlCharEncOutFunc (xmlCharEncodingHandler *handler,
      struct _xmlBuffer *out,
      struct _xmlBuffer *in);

          int
 xmlCharEncInFunc (xmlCharEncodingHandler *handler,
      struct _xmlBuffer *out,
      struct _xmlBuffer *in);
__attribute__((deprecated))
          int
 xmlCharEncFirstLine (xmlCharEncodingHandler *handler,
      struct _xmlBuffer *out,
      struct _xmlBuffer *in);
          int
 xmlCharEncCloseFunc (xmlCharEncodingHandler *handler);





          int
 xmlUTF8ToIsolat1 (unsigned char *out,
      int *outlen,
      const unsigned char *in,
      int *inlen);

          int
 xmlIsolat1ToUTF8 (unsigned char *out,
      int *outlen,
      const unsigned char *in,
      int *inlen);

}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 1
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h" 2



extern "C" {
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef int (*xmlInputMatchCallback) (const char *filename);






typedef void * (*xmlInputOpenCallback) (const char *filename);
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef int (*xmlInputReadCallback) (void * context, char * buffer, int len);






typedef int (*xmlInputCloseCallback) (void * context);
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef int (*xmlOutputMatchCallback) (const char *filename);






typedef void * (*xmlOutputOpenCallback) (const char *filename);
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef int (*xmlOutputWriteCallback) (void * context, const char * buffer,
                                       int len);






typedef int (*xmlOutputCloseCallback) (void * context);
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef xmlParserInputBuffer *
(*xmlParserInputBufferCreateFilenameFunc)(const char *URI, xmlCharEncoding enc);
# 116 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
typedef xmlOutputBuffer *
(*xmlOutputBufferCreateFilenameFunc)(const char *URI,
        xmlCharEncodingHandler *encoder, int compression);







struct _xmlParserInputBuffer {
    void* context __attribute__((deprecated));
    xmlInputReadCallback readcallback __attribute__((deprecated));
    xmlInputCloseCallback closecallback __attribute__((deprecated));


    xmlCharEncodingHandler *encoder __attribute__((deprecated));


    xmlBuf *buffer __attribute__((deprecated));

    xmlBuf *raw __attribute__((deprecated));

    int compressed __attribute__((deprecated));
    int error __attribute__((deprecated));

    unsigned long rawconsumed __attribute__((deprecated));
};






struct _xmlOutputBuffer {
    void* context;
    xmlOutputWriteCallback writecallback;
    xmlOutputCloseCallback closecallback;


    xmlCharEncodingHandler *encoder;


    xmlBuf *buffer;

    xmlBuf *conv;

    int written;
    int error;
};




__attribute__((deprecated))
          xmlParserInputBufferCreateFilenameFunc *
__xmlParserInputBufferCreateFilenameValue(void);
__attribute__((deprecated))
          xmlOutputBufferCreateFilenameFunc *
__xmlOutputBufferCreateFilenameValue(void);
# 189 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
          void
 xmlCleanupInputCallbacks (void);

          int
 xmlPopInputCallbacks (void);

          void
 xmlRegisterDefaultInputCallbacks (void);
          xmlParserInputBuffer *
 xmlAllocParserInputBuffer (xmlCharEncoding enc);

          xmlParserInputBuffer *
 xmlParserInputBufferCreateFilename (const char *URI,
                                                 xmlCharEncoding enc);
__attribute__((deprecated))
          xmlParserInputBuffer *
 xmlParserInputBufferCreateFile (FILE *file,
                                                 xmlCharEncoding enc);
          xmlParserInputBuffer *
 xmlParserInputBufferCreateFd (int fd,
                                          xmlCharEncoding enc);
          xmlParserInputBuffer *
 xmlParserInputBufferCreateMem (const char *mem, int size,
                                          xmlCharEncoding enc);
          xmlParserInputBuffer *
 xmlParserInputBufferCreateStatic (const char *mem, int size,
                                          xmlCharEncoding enc);
          xmlParserInputBuffer *
 xmlParserInputBufferCreateIO (xmlInputReadCallback ioread,
       xmlInputCloseCallback ioclose,
       void *ioctx,
                                          xmlCharEncoding enc);
__attribute__((deprecated))
          int
 xmlParserInputBufferRead (xmlParserInputBuffer *in,
       int len);
__attribute__((deprecated))
          int
 xmlParserInputBufferGrow (xmlParserInputBuffer *in,
       int len);
__attribute__((deprecated))
          int
 xmlParserInputBufferPush (xmlParserInputBuffer *in,
       int len,
       const char *buf);
          void
 xmlFreeParserInputBuffer (xmlParserInputBuffer *in);
          char *
 xmlParserGetDirectory (const char *filename);

          int
 xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc,
       xmlInputOpenCallback openFunc,
       xmlInputReadCallback readFunc,
       xmlInputCloseCallback closeFunc);

          xmlParserInputBuffer *
 __xmlParserInputBufferCreateFilename(const char *URI,
      xmlCharEncoding enc);





          void
 xmlCleanupOutputCallbacks (void);
          int
 xmlPopOutputCallbacks (void);
          void
 xmlRegisterDefaultOutputCallbacks(void);
          xmlOutputBuffer *
 xmlAllocOutputBuffer (xmlCharEncodingHandler *encoder);

          xmlOutputBuffer *
 xmlOutputBufferCreateFilename (const char *URI,
      xmlCharEncodingHandler *encoder,
      int compression);

          xmlOutputBuffer *
 xmlOutputBufferCreateFile (FILE *file,
      xmlCharEncodingHandler *encoder);

          xmlOutputBuffer *
 xmlOutputBufferCreateBuffer (xmlBuffer *buffer,
      xmlCharEncodingHandler *encoder);

          xmlOutputBuffer *
 xmlOutputBufferCreateFd (int fd,
      xmlCharEncodingHandler *encoder);

          xmlOutputBuffer *
 xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite,
      xmlOutputCloseCallback ioclose,
      void *ioctx,
      xmlCharEncodingHandler *encoder);


          const xmlChar *
        xmlOutputBufferGetContent (xmlOutputBuffer *out);
          size_t
        xmlOutputBufferGetSize (xmlOutputBuffer *out);

          int
 xmlOutputBufferWrite (xmlOutputBuffer *out,
      int len,
      const char *buf);
          int
 xmlOutputBufferWriteString (xmlOutputBuffer *out,
      const char *str);
          int
 xmlOutputBufferWriteEscape (xmlOutputBuffer *out,
      const xmlChar *str,
      xmlCharEncodingOutputFunc escaping);

          int
 xmlOutputBufferFlush (xmlOutputBuffer *out);
          int
 xmlOutputBufferClose (xmlOutputBuffer *out);

          int
 xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc,
      xmlOutputOpenCallback openFunc,
      xmlOutputWriteCallback writeFunc,
      xmlOutputCloseCallback closeFunc);

          xmlOutputBuffer *
 __xmlOutputBufferCreateFilename(const char *URI,
                              xmlCharEncodingHandler *encoder,
                              int compression);


__attribute__((deprecated))
          xmlParserInput *
 xmlCheckHTTPInput (xmlParserCtxt *ctxt,
      xmlParserInput *ret);

__attribute__((deprecated))
          xmlParserInput *
 xmlNoNetExternalEntityLoader (const char *URL,
      const char *ID,
      xmlParserCtxt *ctxt);

__attribute__((deprecated))
          xmlChar *
 xmlNormalizeWindowsPath (const xmlChar *path);

__attribute__((deprecated))
          int
 xmlCheckFilename (const char *path);

__attribute__((deprecated))
          int
 xmlFileMatch (const char *filename);
__attribute__((deprecated))
          void *
 xmlFileOpen (const char *filename);
__attribute__((deprecated))
          int
 xmlFileRead (void * context,
      char * buffer,
      int len);
__attribute__((deprecated))
          int
 xmlFileClose (void * context);
# 382 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xmlIO.h"
          xmlParserInputBufferCreateFilenameFunc
 xmlParserInputBufferCreateFilenameDefault(
  xmlParserInputBufferCreateFilenameFunc func);
          xmlOutputBufferCreateFilenameFunc
 xmlOutputBufferCreateFilenameDefault(
  xmlOutputBufferCreateFilenameFunc func);
__attribute__((deprecated))
          xmlOutputBufferCreateFilenameFunc
 xmlThrDefOutputBufferCreateFilenameDefault(
  xmlOutputBufferCreateFilenameFunc func);
__attribute__((deprecated))
          xmlParserInputBufferCreateFilenameFunc
 xmlThrDefParserInputBufferCreateFilenameDefault(
  xmlParserInputBufferCreateFilenameFunc func);


}
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/SAX2.h" 1
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/SAX2.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/SAX2.h" 2


extern "C" {

          const xmlChar *
  xmlSAX2GetPublicId (void *ctx);
          const xmlChar *
  xmlSAX2GetSystemId (void *ctx);
          void
  xmlSAX2SetDocumentLocator (void *ctx,
       xmlSAXLocator *loc);

          int
  xmlSAX2GetLineNumber (void *ctx);
          int
  xmlSAX2GetColumnNumber (void *ctx);

          int
  xmlSAX2IsStandalone (void *ctx);
          int
  xmlSAX2HasInternalSubset (void *ctx);
          int
  xmlSAX2HasExternalSubset (void *ctx);

          void
  xmlSAX2InternalSubset (void *ctx,
       const xmlChar *name,
       const xmlChar *publicId,
       const xmlChar *systemId);
          void
  xmlSAX2ExternalSubset (void *ctx,
       const xmlChar *name,
       const xmlChar *publicId,
       const xmlChar *systemId);
          xmlEntity *
  xmlSAX2GetEntity (void *ctx,
       const xmlChar *name);
          xmlEntity *
  xmlSAX2GetParameterEntity (void *ctx,
       const xmlChar *name);
          xmlParserInput *
  xmlSAX2ResolveEntity (void *ctx,
       const xmlChar *publicId,
       const xmlChar *systemId);

          void
  xmlSAX2EntityDecl (void *ctx,
       const xmlChar *name,
       int type,
       const xmlChar *publicId,
       const xmlChar *systemId,
       xmlChar *content);
          void
  xmlSAX2AttributeDecl (void *ctx,
       const xmlChar *elem,
       const xmlChar *fullname,
       int type,
       int def,
       const xmlChar *defaultValue,
       xmlEnumeration *tree);
          void
  xmlSAX2ElementDecl (void *ctx,
       const xmlChar *name,
       int type,
       xmlElementContent *content);
          void
  xmlSAX2NotationDecl (void *ctx,
       const xmlChar *name,
       const xmlChar *publicId,
       const xmlChar *systemId);
          void
  xmlSAX2UnparsedEntityDecl (void *ctx,
       const xmlChar *name,
       const xmlChar *publicId,
       const xmlChar *systemId,
       const xmlChar *notationName);

          void
  xmlSAX2StartDocument (void *ctx);
          void
  xmlSAX2EndDocument (void *ctx);
__attribute__((deprecated))
          void
  xmlSAX2StartElement (void *ctx,
       const xmlChar *fullname,
       const xmlChar **atts);
__attribute__((deprecated))
          void
  xmlSAX2EndElement (void *ctx,
       const xmlChar *name);
          void
  xmlSAX2StartElementNs (void *ctx,
       const xmlChar *localname,
       const xmlChar *prefix,
       const xmlChar *URI,
       int nb_namespaces,
       const xmlChar **namespaces,
       int nb_attributes,
       int nb_defaulted,
       const xmlChar **attributes);
          void
  xmlSAX2EndElementNs (void *ctx,
       const xmlChar *localname,
       const xmlChar *prefix,
       const xmlChar *URI);
          void
  xmlSAX2Reference (void *ctx,
       const xmlChar *name);
          void
  xmlSAX2Characters (void *ctx,
       const xmlChar *ch,
       int len);
          void
  xmlSAX2IgnorableWhitespace (void *ctx,
       const xmlChar *ch,
       int len);
          void
  xmlSAX2ProcessingInstruction (void *ctx,
       const xmlChar *target,
       const xmlChar *data);
          void
  xmlSAX2Comment (void *ctx,
       const xmlChar *value);
          void
  xmlSAX2CDataBlock (void *ctx,
       const xmlChar *value,
       int len);


__attribute__((deprecated))
          int
  xmlSAXDefaultVersion (int version);


          int
  xmlSAXVersion (xmlSAXHandler *hdlr,
       int version);
          void
  xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr,
       int warning);

          void
  xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
__attribute__((deprecated))
          void
  htmlDefaultSAXHandlerInit (void);

__attribute__((deprecated))
          void
  xmlDefaultSAXHandlerInit (void);

}
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/threads.h" 1
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/threads.h"
extern "C" {



typedef struct _xmlMutex xmlMutex;
typedef xmlMutex *xmlMutexPtr;


typedef struct _xmlRMutex xmlRMutex;
typedef xmlRMutex *xmlRMutexPtr;

          int
   xmlCheckThreadLocalStorage(void);

          xmlMutex *
   xmlNewMutex (void);
          void
   xmlMutexLock (xmlMutex *tok);
          void
   xmlMutexUnlock (xmlMutex *tok);
          void
   xmlFreeMutex (xmlMutex *tok);

          xmlRMutex *
   xmlNewRMutex (void);
          void
   xmlRMutexLock (xmlRMutex *tok);
          void
   xmlRMutexUnlock (xmlRMutex *tok);
          void
   xmlFreeRMutex (xmlRMutex *tok);




__attribute__((deprecated))
          void
   xmlInitThreads (void);
          void
   xmlLockLibrary (void);
          void
   xmlUnlockLibrary(void);
__attribute__((deprecated))
          void
   xmlCleanupThreads(void);
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/threads.h"
}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h" 2


extern "C" {
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef enum {

    XML_STATUS_NOT_WELL_FORMED = (1 << 0),

    XML_STATUS_NOT_NS_WELL_FORMED = (1 << 1),

    XML_STATUS_DTD_VALIDATION_FAILED = (1 << 2),

    XML_STATUS_CATASTROPHIC_ERROR = (1 << 3)
} xmlParserStatus;




typedef enum {

    XML_RESOURCE_UNKNOWN = 0,

    XML_RESOURCE_MAIN_DOCUMENT,

    XML_RESOURCE_DTD,

    XML_RESOURCE_GENERAL_ENTITY,

    XML_RESOURCE_PARAMETER_ENTITY,

    XML_RESOURCE_XINCLUDE,

    XML_RESOURCE_XINCLUDE_TEXT
} xmlResourceType;




typedef enum {

    XML_INPUT_BUF_STATIC = (1 << 1),


    XML_INPUT_BUF_ZERO_TERMINATED = (1 << 2),

    XML_INPUT_UNZIP = (1 << 3),

    XML_INPUT_NETWORK = (1 << 4),

    XML_INPUT_USE_SYS_CATALOG = (1 << 5)
} xmlParserInputFlags;


typedef void (* xmlParserInputDeallocate)(xmlChar *str);




struct _xmlParserInput {

    xmlParserInputBuffer *buf __attribute__((deprecated));





    const char *filename;

    const char *directory __attribute__((deprecated));

    const xmlChar *base;





    const xmlChar *cur;

    const xmlChar *end;

    int length __attribute__((deprecated));





    int line;





    int col;





    unsigned long consumed;

    xmlParserInputDeallocate free __attribute__((deprecated));

    const xmlChar *encoding __attribute__((deprecated));

    const xmlChar *version __attribute__((deprecated));

    int flags __attribute__((deprecated));

    int id __attribute__((deprecated));

    unsigned long parentConsumed __attribute__((deprecated));

    xmlEntity *entity __attribute__((deprecated));
};



typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;

struct _xmlParserNodeInfo {
  const struct _xmlNode* node;

  unsigned long begin_pos;
  unsigned long begin_line;
  unsigned long end_pos;
  unsigned long end_line;
};

typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
struct _xmlParserNodeInfoSeq {
  unsigned long maximum;
  unsigned long length;
  xmlParserNodeInfo* buffer;
};




typedef enum {
    XML_PARSER_EOF = -1,
    XML_PARSER_START = 0,
    XML_PARSER_MISC,
    XML_PARSER_PI,
    XML_PARSER_DTD,
    XML_PARSER_PROLOG,
    XML_PARSER_COMMENT,
    XML_PARSER_START_TAG,
    XML_PARSER_CONTENT,
    XML_PARSER_CDATA_SECTION,
    XML_PARSER_END_TAG,
    XML_PARSER_ENTITY_DECL,
    XML_PARSER_ENTITY_VALUE,
    XML_PARSER_ATTRIBUTE_VALUE,
    XML_PARSER_SYSTEM_LITERAL,
    XML_PARSER_EPILOG,
    XML_PARSER_IGNORE,
    XML_PARSER_PUBLIC_LITERAL,
    XML_PARSER_XML_DECL
} xmlParserInputState;
# 215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef enum {
    XML_PARSE_UNKNOWN = 0,
    XML_PARSE_DOM = 1,
    XML_PARSE_SAX = 2,
    XML_PARSE_PUSH_DOM = 3,
    XML_PARSE_PUSH_SAX = 4,
    XML_PARSE_READER = 5
} xmlParserMode;

typedef struct _xmlStartTag xmlStartTag;
typedef struct _xmlParserNsData xmlParserNsData;
typedef struct _xmlAttrHashBucket xmlAttrHashBucket;
# 249 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef xmlParserErrors
(*xmlResourceLoader)(void *ctxt, const char *url, const char *publicId,
                     xmlResourceType type, xmlParserInputFlags flags,
                     xmlParserInput **out);




struct _xmlParserCtxt {






    struct _xmlSAXHandler *sax;





    void *userData;





    xmlDoc *myDoc;





    int wellFormed;





    int replaceEntities __attribute__((deprecated));





    xmlChar *version;





    xmlChar *encoding;





    int standalone;






    int html;







    xmlParserInput *input;

    int inputNr;

    int inputMax __attribute__((deprecated));

    xmlParserInput **inputTab;
# 336 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    xmlNode *node;

    int nodeNr __attribute__((deprecated));

    int nodeMax __attribute__((deprecated));

    xmlNode **nodeTab __attribute__((deprecated));


    int record_info;

    xmlParserNodeInfoSeq node_seq __attribute__((deprecated));






    int errNo;


    int hasExternalSubset __attribute__((deprecated));

    int hasPErefs __attribute__((deprecated));

    int external __attribute__((deprecated));






    int valid;





    int validate __attribute__((deprecated));





    xmlValidCtxt vctxt;


    xmlParserInputState instate __attribute__((deprecated));

    int token __attribute__((deprecated));







    char *directory;




    const xmlChar *name __attribute__((deprecated));

    int nameNr __attribute__((deprecated));

    int nameMax __attribute__((deprecated));

    const xmlChar **nameTab __attribute__((deprecated));


    long nbChars __attribute__((deprecated));

    long checkIndex __attribute__((deprecated));





    int keepBlanks __attribute__((deprecated));





    int disableSAX __attribute__((deprecated));
# 431 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    int inSubset;






    const xmlChar *intSubName;






    xmlChar *extSubURI;







    xmlChar *extSubSystem;




    int *space __attribute__((deprecated));

    int spaceNr __attribute__((deprecated));

    int spaceMax __attribute__((deprecated));

    int *spaceTab __attribute__((deprecated));


    int depth __attribute__((deprecated));

    xmlParserInput *entity __attribute__((deprecated));

    int charset __attribute__((deprecated));

    int nodelen __attribute__((deprecated));
    int nodemem __attribute__((deprecated));





    int pedantic __attribute__((deprecated));





    void *_private;
# 502 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    int loadsubset __attribute__((deprecated));

    int linenumbers __attribute__((deprecated));





    void *catalogs __attribute__((deprecated));




    int recovery __attribute__((deprecated));

    int progressive __attribute__((deprecated));





    xmlDict *dict;

    const xmlChar **atts __attribute__((deprecated));

    int maxatts __attribute__((deprecated));

    int docdict __attribute__((deprecated));




    const xmlChar *str_xml __attribute__((deprecated));
    const xmlChar *str_xmlns __attribute__((deprecated));
    const xmlChar *str_xml_ns __attribute__((deprecated));






    int sax2 __attribute__((deprecated));

    int nsNr __attribute__((deprecated));

    int nsMax __attribute__((deprecated));

    const xmlChar **nsTab __attribute__((deprecated));

    unsigned *attallocs __attribute__((deprecated));

    xmlStartTag *pushTab __attribute__((deprecated));

    xmlHashTable *attsDefault __attribute__((deprecated));

    xmlHashTable *attsSpecial __attribute__((deprecated));






    int nsWellFormed;





    int options;






    int dictNames __attribute__((deprecated));






    int freeElemsNr __attribute__((deprecated));

    xmlNode *freeElems __attribute__((deprecated));

    int freeAttrsNr __attribute__((deprecated));

    xmlAttr *freeAttrs __attribute__((deprecated));






    xmlError lastError __attribute__((deprecated));

    xmlParserMode parseMode __attribute__((deprecated));

    unsigned long nbentities __attribute__((deprecated));

    unsigned long sizeentities __attribute__((deprecated));



    xmlParserNodeInfo *nodeInfo __attribute__((deprecated));

    int nodeInfoNr __attribute__((deprecated));

    int nodeInfoMax __attribute__((deprecated));

    xmlParserNodeInfo *nodeInfoTab __attribute__((deprecated));


    int input_id __attribute__((deprecated));

    unsigned long sizeentcopy __attribute__((deprecated));


    int endCheckState __attribute__((deprecated));

    unsigned short nbErrors __attribute__((deprecated));

    unsigned short nbWarnings __attribute__((deprecated));

    unsigned maxAmpl __attribute__((deprecated));


    xmlParserNsData *nsdb __attribute__((deprecated));

    unsigned attrHashMax __attribute__((deprecated));

    xmlAttrHashBucket *attrHash __attribute__((deprecated));

    xmlStructuredErrorFunc errorHandler __attribute__((deprecated));
    void *errorCtxt __attribute__((deprecated));

    xmlResourceLoader resourceLoader __attribute__((deprecated));
    void *resourceCtxt __attribute__((deprecated));

    xmlCharEncConvImpl convImpl __attribute__((deprecated));
    void *convCtxt __attribute__((deprecated));
};




struct _xmlSAXLocator {
    const xmlChar *(*getPublicId)(void *ctx);
    const xmlChar *(*getSystemId)(void *ctx);
    int (*getLineNumber)(void *ctx);
    int (*getColumnNumber)(void *ctx);
};
# 667 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef xmlParserInput *(*resolveEntitySAXFunc) (void *ctx,
    const xmlChar *publicId,
    const xmlChar *systemId);
# 678 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*internalSubsetSAXFunc) (void *ctx,
    const xmlChar *name,
    const xmlChar *publicId,
    const xmlChar *systemId);
# 690 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*externalSubsetSAXFunc) (void *ctx,
    const xmlChar *name,
    const xmlChar *publicId,
    const xmlChar *systemId);







typedef xmlEntity *(*getEntitySAXFunc) (void *ctx,
    const xmlChar *name);







typedef xmlEntity *(*getParameterEntitySAXFunc) (void *ctx,
    const xmlChar *name);
# 722 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*entityDeclSAXFunc) (void *ctx,
    const xmlChar *name,
    int type,
    const xmlChar *publicId,
    const xmlChar *systemId,
    xmlChar *content);
# 736 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*notationDeclSAXFunc)(void *ctx,
    const xmlChar *name,
    const xmlChar *publicId,
    const xmlChar *systemId);
# 751 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*attributeDeclSAXFunc)(void *ctx,
    const xmlChar *elem,
    const xmlChar *fullname,
    int type,
    int def,
    const xmlChar *defaultValue,
    xmlEnumeration *tree);
# 766 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*elementDeclSAXFunc)(void *ctx,
    const xmlChar *name,
    int type,
    xmlElementContent *content);
# 779 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
    const xmlChar *name,
    const xmlChar *publicId,
    const xmlChar *systemId,
    const xmlChar *notationName);
# 794 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
    xmlSAXLocator *loc);





typedef void (*startDocumentSAXFunc) (void *ctx);





typedef void (*endDocumentSAXFunc) (void *ctx);







typedef void (*startElementSAXFunc) (void *ctx,
    const xmlChar *name,
    const xmlChar **atts);






typedef void (*endElementSAXFunc) (void *ctx,
    const xmlChar *name);
# 835 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*attributeSAXFunc) (void *ctx,
    const xmlChar *name,
    const xmlChar *value);






typedef void (*referenceSAXFunc) (void *ctx,
    const xmlChar *name);







typedef void (*charactersSAXFunc) (void *ctx,
    const xmlChar *ch,
    int len);







typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
    const xmlChar *ch,
    int len);







typedef void (*processingInstructionSAXFunc) (void *ctx,
    const xmlChar *target,
    const xmlChar *data);






typedef void (*commentSAXFunc) (void *ctx,
    const xmlChar *value);







typedef void (*cdataBlockSAXFunc) (
                         void *ctx,
    const xmlChar *value,
    int len);







typedef void (*warningSAXFunc) (void *ctx,
    const char *msg, ...) __attribute__((__format__(__printf__,2,3)));







typedef void (*errorSAXFunc) (void *ctx,
    const char *msg, ...) __attribute__((__format__(__printf__,2,3)));







typedef void (*fatalErrorSAXFunc) (void *ctx,
    const char *msg, ...) __attribute__((__format__(__printf__,2,3)));






typedef int (*isStandaloneSAXFunc) (void *ctx);






typedef int (*hasInternalSubsetSAXFunc) (void *ctx);







typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
# 974 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*startElementNsSAX2Func) (void *ctx,
     const xmlChar *localname,
     const xmlChar *prefix,
     const xmlChar *URI,
     int nb_namespaces,
     const xmlChar **namespaces,
     int nb_attributes,
     int nb_defaulted,
     const xmlChar **attributes);
# 995 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef void (*endElementNsSAX2Func) (void *ctx,
     const xmlChar *localname,
     const xmlChar *prefix,
     const xmlChar *URI);
# 1007 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
struct _xmlSAXHandler {






    internalSubsetSAXFunc internalSubset;




    isStandaloneSAXFunc isStandalone;




    hasInternalSubsetSAXFunc hasInternalSubset;




    hasExternalSubsetSAXFunc hasExternalSubset;






    resolveEntitySAXFunc resolveEntity;





    getEntitySAXFunc getEntity;





    entityDeclSAXFunc entityDecl;





    notationDeclSAXFunc notationDecl;





    attributeDeclSAXFunc attributeDecl;





    elementDeclSAXFunc elementDecl;





    unparsedEntityDeclSAXFunc unparsedEntityDecl;







    setDocumentLocatorSAXFunc setDocumentLocator;






    startDocumentSAXFunc startDocument;



    endDocumentSAXFunc endDocument;
# 1107 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    startElementSAXFunc startElement;



    endElementSAXFunc endElement;



    referenceSAXFunc reference;



    charactersSAXFunc characters;







    ignorableWhitespaceSAXFunc ignorableWhitespace;



    processingInstructionSAXFunc processingInstruction;



    commentSAXFunc comment;



    warningSAXFunc warning;



    errorSAXFunc error;



    fatalErrorSAXFunc fatalError;





    getParameterEntitySAXFunc getParameterEntity;



    cdataBlockSAXFunc cdataBlock;





    externalSubsetSAXFunc externalSubset;






    unsigned int initialized;



    void *_private;



    startElementNsSAX2Func startElementNs;



    endElementNsSAX2Func endElementNs;






    xmlStructuredErrorFunc serror;
};






typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;





struct _xmlSAXHandlerV1 {
    internalSubsetSAXFunc internalSubset;
    isStandaloneSAXFunc isStandalone;
    hasInternalSubsetSAXFunc hasInternalSubset;
    hasExternalSubsetSAXFunc hasExternalSubset;
    resolveEntitySAXFunc resolveEntity;
    getEntitySAXFunc getEntity;
    entityDeclSAXFunc entityDecl;
    notationDeclSAXFunc notationDecl;
    attributeDeclSAXFunc attributeDecl;
    elementDeclSAXFunc elementDecl;
    unparsedEntityDeclSAXFunc unparsedEntityDecl;
    setDocumentLocatorSAXFunc setDocumentLocator;
    startDocumentSAXFunc startDocument;
    endDocumentSAXFunc endDocument;
    startElementSAXFunc startElement;
    endElementSAXFunc endElement;
    referenceSAXFunc reference;
    charactersSAXFunc characters;
    ignorableWhitespaceSAXFunc ignorableWhitespace;
    processingInstructionSAXFunc processingInstruction;
    commentSAXFunc comment;
    warningSAXFunc warning;
    errorSAXFunc error;
    fatalErrorSAXFunc fatalError;
    getParameterEntitySAXFunc getParameterEntity;
    cdataBlockSAXFunc cdataBlock;
    externalSubsetSAXFunc externalSubset;
    unsigned int initialized;
};
# 1247 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef xmlParserInput *(*xmlExternalEntityLoader) (const char *URL,
      const char *publicId,
      xmlParserCtxt *context);





extern const char *const xmlParserVersion;



__attribute__((deprecated))
extern const xmlSAXLocator xmlDefaultSAXLocator;




__attribute__((deprecated))
extern const xmlSAXHandlerV1 xmlDefaultSAXHandler;


__attribute__((deprecated))
          int *__xmlDoValidityCheckingDefaultValue(void);
__attribute__((deprecated))
          int *__xmlGetWarningsDefaultValue(void);
__attribute__((deprecated))
          int *__xmlKeepBlanksDefaultValue(void);
__attribute__((deprecated))
          int *__xmlLineNumbersDefaultValue(void);
__attribute__((deprecated))
          int *__xmlLoadExtDtdDefaultValue(void);
__attribute__((deprecated))
          int *__xmlPedanticParserDefaultValue(void);
__attribute__((deprecated))
          int *__xmlSubstituteEntitiesDefaultValue(void);


__attribute__((deprecated))
          int *__xmlIndentTreeOutput(void);
__attribute__((deprecated))
          const char **__xmlTreeIndentString(void);
__attribute__((deprecated))
          int *__xmlSaveNoEmptyTags(void);
# 1379 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
          void
  xmlInitParser (void);
          void
  xmlCleanupParser (void);
__attribute__((deprecated))
          void
  xmlInitGlobals (void);
__attribute__((deprecated))
          void
  xmlCleanupGlobals (void);




__attribute__((deprecated))
          int
  xmlParserInputRead (xmlParserInput *in,
      int len);
          int
  xmlParserInputGrow (xmlParserInput *in,
      int len);





          xmlDoc *
  xmlParseDoc (const xmlChar *cur);
          xmlDoc *
  xmlParseFile (const char *filename);
          xmlDoc *
  xmlParseMemory (const char *buffer,
      int size);

__attribute__((deprecated))
          int
  xmlSubstituteEntitiesDefault(int val);
          int
  xmlKeepBlanksDefault (int val);
          void
  xmlStopParser (xmlParserCtxt *ctxt);
__attribute__((deprecated))
          int
  xmlPedanticParserDefault(int val);
__attribute__((deprecated))
          int
  xmlLineNumbersDefault (int val);

__attribute__((deprecated))
          int
                xmlThrDefSubstituteEntitiesDefaultValue(int v);
__attribute__((deprecated))
          int
  xmlThrDefKeepBlanksDefaultValue(int v);
__attribute__((deprecated))
          int
                xmlThrDefPedanticParserDefaultValue(int v);
__attribute__((deprecated))
          int
                xmlThrDefLineNumbersDefaultValue(int v);
__attribute__((deprecated))
          int
                xmlThrDefDoValidityCheckingDefaultValue(int v);
__attribute__((deprecated))
          int
                xmlThrDefGetWarningsDefaultValue(int v);
__attribute__((deprecated))
          int
                xmlThrDefLoadExtDtdDefaultValue(int v);





__attribute__((deprecated))
          xmlDoc *
  xmlRecoverDoc (const xmlChar *cur);
__attribute__((deprecated))
          xmlDoc *
  xmlRecoverMemory (const char *buffer,
      int size);
__attribute__((deprecated))
          xmlDoc *
  xmlRecoverFile (const char *filename);





          int
  xmlParseDocument (xmlParserCtxt *ctxt);
__attribute__((deprecated))
          int
  xmlParseExtParsedEnt (xmlParserCtxt *ctxt);

__attribute__((deprecated))
          int
  xmlSAXUserParseFile (xmlSAXHandler *sax,
      void *user_data,
      const char *filename);
__attribute__((deprecated))
          int
  xmlSAXUserParseMemory (xmlSAXHandler *sax,
      void *user_data,
      const char *buffer,
      int size);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseDoc (xmlSAXHandler *sax,
      const xmlChar *cur,
      int recovery);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseMemory (xmlSAXHandler *sax,
      const char *buffer,
      int size,
      int recovery);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseMemoryWithData (xmlSAXHandler *sax,
      const char *buffer,
      int size,
      int recovery,
      void *data);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseFile (xmlSAXHandler *sax,
      const char *filename,
      int recovery);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseFileWithData (xmlSAXHandler *sax,
      const char *filename,
      int recovery,
      void *data);
__attribute__((deprecated))
          xmlDoc *
  xmlSAXParseEntity (xmlSAXHandler *sax,
      const char *filename);
__attribute__((deprecated))
          xmlDoc *
  xmlParseEntity (const char *filename);



          xmlDtd *
  xmlCtxtParseDtd (xmlParserCtxt *ctxt,
      xmlParserInput *input,
      const xmlChar *publicId,
      const xmlChar *systemId);
          int
  xmlCtxtValidateDocument (xmlParserCtxt *ctxt,
      xmlDoc *doc);
          int
  xmlCtxtValidateDtd (xmlParserCtxt *ctxt,
      xmlDoc *doc,
      xmlDtd *dtd);
__attribute__((deprecated))
          xmlDtd *
  xmlSAXParseDTD (xmlSAXHandler *sax,
      const xmlChar *publicId,
      const xmlChar *systemId);
          xmlDtd *
  xmlParseDTD (const xmlChar *publicId,
      const xmlChar *systemId);
          xmlDtd *
  xmlIOParseDTD (xmlSAXHandler *sax,
      xmlParserInputBuffer *input,
      xmlCharEncoding enc);


          int
  xmlParseBalancedChunkMemory(xmlDoc *doc,
      xmlSAXHandler *sax,
      void *user_data,
      int depth,
      const xmlChar *string,
      xmlNode **lst);

          xmlParserErrors
  xmlParseInNodeContext (xmlNode *node,
      const char *data,
      int datalen,
      int options,
      xmlNode **lst);

          int
  xmlParseBalancedChunkMemoryRecover(xmlDoc *doc,
                     xmlSAXHandler *sax,
                     void *user_data,
                     int depth,
                     const xmlChar *string,
                     xmlNode **lst,
                     int recover);
__attribute__((deprecated))
          int
  xmlParseExternalEntity (xmlDoc *doc,
      xmlSAXHandler *sax,
      void *user_data,
      int depth,
      const xmlChar *URL,
      const xmlChar *ID,
      xmlNode **lst);

          int
  xmlParseCtxtExternalEntity(xmlParserCtxt *ctx,
      const xmlChar *URL,
      const xmlChar *ID,
      xmlNode **lst);




          xmlParserCtxt *
  xmlNewParserCtxt (void);
          xmlParserCtxt *
  xmlNewSAXParserCtxt (const xmlSAXHandler *sax,
      void *userData);
          int
  xmlInitParserCtxt (xmlParserCtxt *ctxt);
__attribute__((deprecated))
          void
  xmlClearParserCtxt (xmlParserCtxt *ctxt);
          void
  xmlFreeParserCtxt (xmlParserCtxt *ctxt);

__attribute__((deprecated))
          void
  xmlSetupParserForBuffer (xmlParserCtxt *ctxt,
      const xmlChar* buffer,
      const char *filename);

          xmlParserCtxt *
  xmlCreateDocParserCtxt (const xmlChar *cur);





          xmlParserCtxt *
  xmlCreatePushParserCtxt(xmlSAXHandler *sax,
      void *user_data,
      const char *chunk,
      int size,
      const char *filename);
          int
  xmlParseChunk (xmlParserCtxt *ctxt,
      const char *chunk,
      int size,
      int terminate);






          xmlParserCtxt *
  xmlCreateIOParserCtxt (xmlSAXHandler *sax,
      void *user_data,
      xmlInputReadCallback ioread,
      xmlInputCloseCallback ioclose,
      void *ioctx,
      xmlCharEncoding enc);

          xmlParserInput *
  xmlNewIOInputStream (xmlParserCtxt *ctxt,
      xmlParserInputBuffer *input,
      xmlCharEncoding enc);




__attribute__((deprecated))
          const xmlParserNodeInfo*
  xmlParserFindNodeInfo (xmlParserCtxt *ctxt,
             xmlNode *node);
__attribute__((deprecated))
          void
  xmlInitNodeInfoSeq (xmlParserNodeInfoSeq *seq);
__attribute__((deprecated))
          void
  xmlClearNodeInfoSeq (xmlParserNodeInfoSeq *seq);
__attribute__((deprecated))
          unsigned long
  xmlParserFindNodeInfoIndex(xmlParserNodeInfoSeq *seq,
                                         xmlNode *node);
__attribute__((deprecated))
          void
  xmlParserAddNodeInfo (xmlParserCtxt *ctxt,
      xmlParserNodeInfo *info);





          void
  xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
          xmlExternalEntityLoader
  xmlGetExternalEntityLoader(void);
          xmlParserInput *
  xmlLoadExternalEntity (const char *URL,
      const char *ID,
      xmlParserCtxt *ctxt);

__attribute__((deprecated))
          long
  xmlByteConsumed (xmlParserCtxt *ctxt);
# 1695 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef enum {







    XML_PARSE_RECOVER = 1<<0,
# 1715 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    XML_PARSE_NOENT = 1<<1,





    XML_PARSE_DTDLOAD = 1<<2,






    XML_PARSE_DTDATTR = 1<<3,
# 1737 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    XML_PARSE_DTDVALID = 1<<4,




    XML_PARSE_NOERROR = 1<<5,



    XML_PARSE_NOWARNING = 1<<6,



    XML_PARSE_PEDANTIC = 1<<7,
# 1759 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    XML_PARSE_NOBLANKS = 1<<8,






    XML_PARSE_SAX1 = 1<<9,




    XML_PARSE_XINCLUDE = 1<<10,







    XML_PARSE_NONET = 1<<11,




    XML_PARSE_NODICT = 1<<12,




    XML_PARSE_NSCLEAN = 1<<13,



    XML_PARSE_NOCDATA = 1<<14,





    XML_PARSE_NOXINCNODE = 1<<15,




    XML_PARSE_COMPACT = 1<<16,





    XML_PARSE_OLD10 = 1<<17,




    XML_PARSE_NOBASEFIX = 1<<18,
# 1840 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
    XML_PARSE_HUGE = 1<<19,





    XML_PARSE_OLDSAX = 1<<20,





    XML_PARSE_IGNORE_ENC = 1<<21,



    XML_PARSE_BIG_LINES = 1<<22,





    XML_PARSE_NO_XXE = 1<<23,






    XML_PARSE_UNZIP = 1<<24,





    XML_PARSE_NO_SYS_CATALOG = 1<<25,





    XML_PARSE_CATALOG_PI = 1<<26,





    XML_PARSE_SKIP_IDS = 1<<27
} xmlParserOption;

          void
  xmlCtxtReset (xmlParserCtxt *ctxt);
          int
  xmlCtxtResetPush (xmlParserCtxt *ctxt,
      const char *chunk,
      int size,
      const char *filename,
      const char *encoding);
          int
  xmlCtxtGetOptions (xmlParserCtxt *ctxt);
          int
  xmlCtxtSetOptions (xmlParserCtxt *ctxt,
      int options);
          int
  xmlCtxtUseOptions (xmlParserCtxt *ctxt,
      int options);
          void *
  xmlCtxtGetPrivate (xmlParserCtxt *ctxt);
          void
  xmlCtxtSetPrivate (xmlParserCtxt *ctxt,
      void *priv);
          void *
  xmlCtxtGetCatalogs (xmlParserCtxt *ctxt);
          void
  xmlCtxtSetCatalogs (xmlParserCtxt *ctxt,
      void *catalogs);
          xmlDict *
  xmlCtxtGetDict (xmlParserCtxt *ctxt);
          void
  xmlCtxtSetDict (xmlParserCtxt *ctxt,
      xmlDict *);
          xmlSAXHandler *
  xmlCtxtGetSaxHandler (xmlParserCtxt *ctxt);
          int
  xmlCtxtSetSaxHandler (xmlParserCtxt *ctxt,
      const xmlSAXHandler *sax);
          xmlDoc *
  xmlCtxtGetDocument (xmlParserCtxt *ctxt);
          int
  xmlCtxtIsHtml (xmlParserCtxt *ctxt);
          int
  xmlCtxtIsStopped (xmlParserCtxt *ctxt);
          int
  xmlCtxtIsInSubset (xmlParserCtxt *ctxt);

          xmlValidCtxt *
  xmlCtxtGetValidCtxt (xmlParserCtxt *ctxt);

          const xmlChar *
  xmlCtxtGetVersion (xmlParserCtxt *ctxt);
          const xmlChar *
  xmlCtxtGetDeclaredEncoding(xmlParserCtxt *ctxt);
          int
  xmlCtxtGetStandalone (xmlParserCtxt *ctxt);
          xmlParserStatus
  xmlCtxtGetStatus (xmlParserCtxt *ctxt);
          void *
  xmlCtxtGetUserData (xmlParserCtxt *ctxt);
          xmlNode *
  xmlCtxtGetNode (xmlParserCtxt *ctxt);
          int
  xmlCtxtGetDocTypeDecl (xmlParserCtxt *ctxt,
      const xmlChar **name,
      const xmlChar **systemId,
      const xmlChar **publicId);
          int
  xmlCtxtGetInputPosition (xmlParserCtxt *ctxt,
      int inputIndex,
      const char **filname,
      int *line,
      int *col,
      unsigned long *bytePos);
          int
  xmlCtxtGetInputWindow (xmlParserCtxt *ctxt,
      int inputIndex,
      const xmlChar **startOut,
      int *sizeInOut,
      int *offsetOut);
          void
  xmlCtxtSetErrorHandler (xmlParserCtxt *ctxt,
      xmlStructuredErrorFunc handler,
      void *data);
          void
  xmlCtxtSetResourceLoader(xmlParserCtxt *ctxt,
      xmlResourceLoader loader,
      void *vctxt);
          void
  xmlCtxtSetCharEncConvImpl(xmlParserCtxt *ctxt,
      xmlCharEncConvImpl impl,
      void *vctxt);
          void
  xmlCtxtSetMaxAmplification(xmlParserCtxt *ctxt,
      unsigned maxAmpl);
          xmlDoc *
  xmlReadDoc (const xmlChar *cur,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlReadFile (const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlReadMemory (const char *buffer,
      int size,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlReadFd (int fd,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlReadIO (xmlInputReadCallback ioread,
      xmlInputCloseCallback ioclose,
      void *ioctx,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlCtxtParseDocument (xmlParserCtxt *ctxt,
      xmlParserInput *input);
          xmlNode *
  xmlCtxtParseContent (xmlParserCtxt *ctxt,
      xmlParserInput *input,
      xmlNode *node,
      int hasTextDecl);
          xmlDoc *
  xmlCtxtReadDoc (xmlParserCtxt *ctxt,
      const xmlChar *cur,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlCtxtReadFile (xmlParserCtxt *ctxt,
      const char *filename,
      const char *encoding,
      int options);
          xmlDoc *
  xmlCtxtReadMemory (xmlParserCtxt *ctxt,
      const char *buffer,
      int size,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlCtxtReadFd (xmlParserCtxt *ctxt,
      int fd,
      const char *URL,
      const char *encoding,
      int options);
          xmlDoc *
  xmlCtxtReadIO (xmlParserCtxt *ctxt,
      xmlInputReadCallback ioread,
      xmlInputCloseCallback ioclose,
      void *ioctx,
      const char *URL,
      const char *encoding,
      int options);





          xmlParserErrors
xmlNewInputFromUrl(const char *url, xmlParserInputFlags flags,
                   xmlParserInput **out);
          xmlParserInput *
xmlNewInputFromMemory(const char *url, const void *mem, size_t size,
                      xmlParserInputFlags flags);
          xmlParserInput *
xmlNewInputFromString(const char *url, const char *str,
                      xmlParserInputFlags flags);
          xmlParserInput *
xmlNewInputFromFd(const char *url, int fd, xmlParserInputFlags flags);
          xmlParserInput *
xmlNewInputFromIO(const char *url, xmlInputReadCallback ioRead,
                  xmlInputCloseCallback ioClose, void *ioCtxt,
                  xmlParserInputFlags flags);
          xmlParserErrors
xmlInputSetEncodingHandler(xmlParserInput *input,
                           xmlCharEncodingHandler *handler);
# 2083 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/parser.h"
typedef enum {

    XML_WITH_THREAD = 1,

    XML_WITH_TREE = 2,

    XML_WITH_OUTPUT = 3,

    XML_WITH_PUSH = 4,

    XML_WITH_READER = 5,

    XML_WITH_PATTERN = 6,

    XML_WITH_WRITER = 7,

    XML_WITH_SAX1 = 8,

    XML_WITH_FTP = 9,

    XML_WITH_HTTP = 10,

    XML_WITH_VALID = 11,

    XML_WITH_HTML = 12,

    XML_WITH_LEGACY = 13,

    XML_WITH_C14N = 14,

    XML_WITH_CATALOG = 15,

    XML_WITH_XPATH = 16,

    XML_WITH_XPTR = 17,

    XML_WITH_XINCLUDE = 18,

    XML_WITH_ICONV = 19,

    XML_WITH_ISO8859X = 20,

    XML_WITH_UNICODE = 21,

    XML_WITH_REGEXP = 22,

    XML_WITH_AUTOMATA = 23,

    XML_WITH_EXPR = 24,

    XML_WITH_SCHEMAS = 25,

    XML_WITH_SCHEMATRON = 26,

    XML_WITH_MODULES = 27,

    XML_WITH_DEBUG = 28,

    XML_WITH_DEBUG_MEM = 29,

    XML_WITH_DEBUG_RUN = 30,

    XML_WITH_ZLIB = 31,

    XML_WITH_ICU = 32,

    XML_WITH_LZMA = 33,

    XML_WITH_RELAXNG = 34,
    XML_WITH_NONE = 99999
} xmlFeature;

          int
  xmlHasFeature (xmlFeature feature);


}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/tree.h" 2
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h" 2



extern "C" {



typedef struct _xmlXPathContext xmlXPathContext;
typedef xmlXPathContext *xmlXPathContextPtr;

typedef struct _xmlXPathParserContext xmlXPathParserContext;
typedef xmlXPathParserContext *xmlXPathParserContextPtr;





typedef enum {
    XPATH_EXPRESSION_OK = 0,
    XPATH_NUMBER_ERROR,
    XPATH_UNFINISHED_LITERAL_ERROR,
    XPATH_START_LITERAL_ERROR,
    XPATH_VARIABLE_REF_ERROR,
    XPATH_UNDEF_VARIABLE_ERROR,
    XPATH_INVALID_PREDICATE_ERROR,
    XPATH_EXPR_ERROR,
    XPATH_UNCLOSED_ERROR,
    XPATH_UNKNOWN_FUNC_ERROR,
    XPATH_INVALID_OPERAND,
    XPATH_INVALID_TYPE,
    XPATH_INVALID_ARITY,
    XPATH_INVALID_CTXT_SIZE,
    XPATH_INVALID_CTXT_POSITION,
    XPATH_MEMORY_ERROR,
    XPTR_SYNTAX_ERROR,
    XPTR_RESOURCE_ERROR,
    XPTR_SUB_RESOURCE_ERROR,
    XPATH_UNDEF_PREFIX_ERROR,
    XPATH_ENCODING_ERROR,
    XPATH_INVALID_CHAR_ERROR,
    XPATH_INVALID_CTXT,
    XPATH_STACK_ERROR,
    XPATH_FORBID_VARIABLE_ERROR,
    XPATH_OP_LIMIT_EXCEEDED,
    XPATH_RECURSION_LIMIT_EXCEEDED
} xmlXPathError;


typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;



struct _xmlNodeSet {

    int nodeNr;

    int nodeMax;

    xmlNode **nodeTab;
};
# 102 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
typedef enum {
    XPATH_UNDEFINED = 0,
    XPATH_NODESET = 1,
    XPATH_BOOLEAN = 2,
    XPATH_NUMBER = 3,
    XPATH_STRING = 4,
    XPATH_USERS = 8,
    XPATH_XSLT_TREE = 9
} xmlXPathObjectType;
# 119 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
typedef struct _xmlXPathObject xmlXPathObject;
typedef xmlXPathObject *xmlXPathObjectPtr;



struct _xmlXPathObject {

    xmlXPathObjectType type;

    xmlNodeSet *nodesetval;

    int boolval;

    double floatval;

    xmlChar *stringval;
    void *user;
    int index;
    void *user2;
    int index2;
};






typedef int (*xmlXPathConvertFunc) (xmlXPathObject *obj, int type);
typedef struct _xmlXPathType xmlXPathType;
typedef xmlXPathType *xmlXPathTypePtr;
struct _xmlXPathType {
    const xmlChar *name;
    xmlXPathConvertFunc func;
};




typedef struct _xmlXPathVariable xmlXPathVariable;
typedef xmlXPathVariable *xmlXPathVariablePtr;
struct _xmlXPathVariable {
    const xmlChar *name;
    xmlXPathObject *value;
};




typedef void (*xmlXPathEvalFunc)(xmlXPathParserContext *ctxt,
                          int nargs);
typedef struct _xmlXPathFunct xmlXPathFunct;
typedef xmlXPathFunct *xmlXPathFuncPtr;
struct _xmlXPathFunct {
    const xmlChar *name;
    xmlXPathEvalFunc func;
};




typedef xmlXPathObject *(*xmlXPathAxisFunc) (xmlXPathParserContext *ctxt,
     xmlXPathObject *cur);
typedef struct _xmlXPathAxis xmlXPathAxis;
typedef xmlXPathAxis *xmlXPathAxisPtr;
struct _xmlXPathAxis {
    const xmlChar *name;
    xmlXPathAxisFunc func;
};
# 199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
typedef void (*xmlXPathFunction) (xmlXPathParserContext *ctxt, int nargs);
# 214 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
typedef xmlXPathObject *(*xmlXPathVariableLookupFunc) (void *ctxt,
                                         const xmlChar *name,
                                         const xmlChar *ns_uri);
# 227 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
      const xmlChar *name,
      const xmlChar *ns_uri);
# 257 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
struct _xmlXPathContext {

    xmlDoc *doc;

    xmlNode *node;


    int nb_variables_unused;

    int max_variables_unused;

    xmlHashTable *varHash;


    int nb_types;

    int max_types;

    xmlXPathType *types;


    int nb_funcs_unused;

    int max_funcs_unused;

    xmlHashTable *funcHash;


    int nb_axis;

    int max_axis;

    xmlXPathAxis *axis;


    xmlNs **namespaces;

    int nsNr;

    void *user;


    int contextSize;

    int proximityPosition;


    int xptr;

    xmlNode *here;

    xmlNode *origin;


    xmlHashTable *nsHash;

    xmlXPathVariableLookupFunc varLookupFunc;

    void *varLookupData;


    void *extra;


    const xmlChar *function;

    const xmlChar *functionURI;


    xmlXPathFuncLookupFunc funcLookupFunc;

    void *funcLookupData;


    xmlNs **tmpNsList;

    int tmpNsNr;


    void *userData;

    xmlStructuredErrorFunc error;

    xmlError lastError;

    xmlNode *debugNode;


    xmlDict *dict;


    int flags;


    void *cache;


    unsigned long opLimit;
    unsigned long opCount;
    int depth;
};


typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
typedef xmlXPathCompExpr *xmlXPathCompExprPtr;







struct _xmlXPathParserContext {

    const xmlChar *cur;

    const xmlChar *base;


    int error;


    xmlXPathContext *context;

    xmlXPathObject *value;

    int valueNr;

    int valueMax;

    xmlXPathObject **valueTab;


    xmlXPathCompExpr *comp;

    int xptr;

    xmlNode *ancestor;


    int valueFrame;
};
# 412 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
__attribute__((deprecated))
extern double xmlXPathNAN;
__attribute__((deprecated))
extern double xmlXPathPINF;
__attribute__((deprecated))
extern double xmlXPathNINF;
# 451 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2/libxml/xpath.h"
          void
      xmlXPathFreeObject (xmlXPathObject *obj);
          xmlNodeSet *
      xmlXPathNodeSetCreate (xmlNode *val);
          void
      xmlXPathFreeNodeSetList (xmlXPathObject *obj);
          void
      xmlXPathFreeNodeSet (xmlNodeSet *obj);
          xmlXPathObject *
      xmlXPathObjectCopy (xmlXPathObject *val);
          int
      xmlXPathCmpNodes (xmlNode *node1,
       xmlNode *node2);



          int
      xmlXPathCastNumberToBoolean (double val);
          int
      xmlXPathCastStringToBoolean (const xmlChar * val);
          int
      xmlXPathCastNodeSetToBoolean(xmlNodeSet *ns);
          int
      xmlXPathCastToBoolean (xmlXPathObject *val);

          double
      xmlXPathCastBooleanToNumber (int val);
          double
      xmlXPathCastStringToNumber (const xmlChar * val);
          double
      xmlXPathCastNodeToNumber (xmlNode *node);
          double
      xmlXPathCastNodeSetToNumber (xmlNodeSet *ns);
          double
      xmlXPathCastToNumber (xmlXPathObject *val);

          xmlChar *
      xmlXPathCastBooleanToString (int val);
          xmlChar *
      xmlXPathCastNumberToString (double val);
          xmlChar *
      xmlXPathCastNodeToString (xmlNode *node);
          xmlChar *
      xmlXPathCastNodeSetToString (xmlNodeSet *ns);
          xmlChar *
      xmlXPathCastToString (xmlXPathObject *val);

          xmlXPathObject *
      xmlXPathConvertBoolean (xmlXPathObject *val);
          xmlXPathObject *
      xmlXPathConvertNumber (xmlXPathObject *val);
          xmlXPathObject *
      xmlXPathConvertString (xmlXPathObject *val);




          xmlXPathContext *
      xmlXPathNewContext (xmlDoc *doc);
          void
      xmlXPathFreeContext (xmlXPathContext *ctxt);
          void
      xmlXPathSetErrorHandler(xmlXPathContext *ctxt,
         xmlStructuredErrorFunc handler,
         void *context);
          int
      xmlXPathContextSetCache(xmlXPathContext *ctxt,
                int active,
         int value,
         int options);



          long
      xmlXPathOrderDocElems (xmlDoc *doc);
          int
      xmlXPathSetContextNode (xmlNode *node,
       xmlXPathContext *ctx);
          xmlXPathObject *
      xmlXPathNodeEval (xmlNode *node,
       const xmlChar *str,
       xmlXPathContext *ctx);
          xmlXPathObject *
      xmlXPathEval (const xmlChar *str,
       xmlXPathContext *ctx);
          xmlXPathObject *
      xmlXPathEvalExpression (const xmlChar *str,
       xmlXPathContext *ctxt);
          int
      xmlXPathEvalPredicate (xmlXPathContext *ctxt,
       xmlXPathObject *res);



          xmlXPathCompExpr *
      xmlXPathCompile (const xmlChar *str);
          xmlXPathCompExpr *
      xmlXPathCtxtCompile (xmlXPathContext *ctxt,
       const xmlChar *str);
          xmlXPathObject *
      xmlXPathCompiledEval (xmlXPathCompExpr *comp,
       xmlXPathContext *ctx);
          int
      xmlXPathCompiledEvalToBoolean(xmlXPathCompExpr *comp,
       xmlXPathContext *ctxt);
          void
      xmlXPathFreeCompExpr (xmlXPathCompExpr *comp);

__attribute__((deprecated))
          void
      xmlXPathInit (void);
          int
  xmlXPathIsNaN (double val);
          int
  xmlXPathIsInf (double val);


}
# 12 "include/framework/gearbox/Gearbox.h" 2


# 1 "include/framework/gearbox/InputHandler.h" 1
# 13 "include/framework/gearbox/InputHandler.h"
namespace Belle2 {
  namespace gearbox {






    class InputContext {
    public:
# 31 "include/framework/gearbox/InputHandler.h"
      virtual int readXmlData(char* buffer, int buffsize) = 0;

      virtual ~InputContext() {}
    protected:
    };







    class InputHandler {
    public:




      typedef InputHandler* Factory(const std::string& uri);
# 59 "include/framework/gearbox/InputHandler.h"
      explicit InputHandler(const std::string& uri): m_uri(uri) {};


      virtual ~InputHandler() {}
# 72 "include/framework/gearbox/InputHandler.h"
      virtual InputContext* open(const std::string& path) = 0;
    protected:

      std::string m_uri;
    };
  }
}
# 15 "include/framework/gearbox/Gearbox.h" 2





namespace Belle2 {
  namespace gearbox {
    void* openXmlUri(const char*);
  }
  template <class KEY, class VALUE> class MRUCache;





  class Gearbox: public gearbox::Interface {
  public:

    enum { c_DefaultCacheSize = 200 };


    struct PathValue {
      PathValue(): numNodes(0), value(""), unit("") {}

      int numNodes;

      std::string value;

      std::string unit;
    };


    struct PathOverride {

      std::string path {""};

      std::string value {""};

      std::string unit {""};


      bool multiple {false};
    };


    ~Gearbox() override;


    static Gearbox& getInstance();







    void setBackends(const std::vector<std::string>& backends);


    void clearBackends();


    void addOverride(const PathOverride& poverride)
    {
      m_overrides.push_back(poverride);
    }


    void clearOverrides()
    {
      m_overrides.clear();
    }






    void open(const std::string& name = "Belle2.xml", size_t cacheSize = c_DefaultCacheSize);


    void close();





    bool isOpen() const { return m_xmlDocument != 0; }





    virtual int getNumberNodes(const std::string& path = "") const override
    {
      return getPathValue(path).numNodes;
    }







    virtual std::string getString(const std::string& path = "") const noexcept(false) override
    {
      PathValue p = getPathValue(path);
      if (p.numNodes == 0) throw gearbox::PathEmptyError() << path;
      return p.value;
    }
# 134 "include/framework/gearbox/Gearbox.h"
    std::string getString(const std::string& path, const std::string& defaultValue) const
    {
      return gearbox::Interface::getString(path, defaultValue);
    }
# 150 "include/framework/gearbox/Gearbox.h"
    virtual std::pair<std::string, std::string> getStringWithUnit(const std::string& path = "") const noexcept(false) override
    {
      PathValue p = getPathValue(path);
      if (!p.numNodes) throw gearbox::PathEmptyError() << path;
      return make_pair(p.value, p.unit);
    }
# 166 "include/framework/gearbox/Gearbox.h"
    virtual const TObject* getTObject(const std::string& path) const noexcept(false) override;






    static GearDir getDetectorComponent(const std::string& component);
# 183 "include/framework/gearbox/Gearbox.h"
    static void registerInputHandler(const std::string& prefix, gearbox::InputHandler::Factory* factory)
    {
      getInstance().m_registeredHandlers[prefix] = factory;
    }

  private:

    Gearbox();

    Gearbox(const Gearbox&) = delete;

    Gearbox& operator=(const Gearbox&) = delete;


    gearbox::InputContext* openXmlUri(const std::string& uri) const;


    void overridePathValue(const PathOverride& poverride);

    PathValue getPathValue(const std::string& path) const;


    xmlDocPtr m_xmlDocument;

    xmlXPathContextPtr m_xpathContext;

    mutable MRUCache<std::string, PathValue>* m_parameterCache;

    mutable std::map<std::string, TObject*> m_ownedObjects;


    std::vector<gearbox::InputHandler*> m_handlers;

    std::map<std::string, gearbox::InputHandler::Factory*> m_registeredHandlers;


    std::vector<PathOverride> m_overrides;
# 228 "include/framework/gearbox/Gearbox.h"
    friend void* gearbox::openXmlUri(const char*);
  };


  template<class T> struct InputHandlerFactory {

    explicit InputHandlerFactory(const std::string& prefix)
    {
      Gearbox::registerInputHandler(prefix, factory);
    }

    static gearbox::InputHandler* factory(const std::string& uri)
    {
      return new T(uri);
    }
  };
# 254 "include/framework/gearbox/Gearbox.h"
}
# 13 "include/framework/gearbox/GearDir.h" 2

namespace Belle2 {
# 27 "include/framework/gearbox/GearDir.h"
  class GearDir: public gearbox::Interface {
  public:

    GearDir(const gearbox::Interface& start, const std::string& path, int index = 0)
    {
      m_path = ensurePath(start.getPath()) + path;
      if (index > 0) m_path = addIndex(m_path, index);
    }

    explicit GearDir(const std::string& path = "", int index = 0)
    {
      m_path = path;
      if (index > 0) m_path = addIndex(path, index);
    }

    GearDir(const GearDir& other): gearbox::Interface(other)
    {
      m_path = other.m_path;
    }


    void append(const std::string& path) { m_path += path; }





    virtual int getNumberNodes(const std::string& path = "") const override
    {
      return Gearbox::getInstance().getNumberNodes(ensurePath(m_path) + path);
    }







    virtual std::string getString(const std::string& path = "") const noexcept(false) override
    {
      return Gearbox::getInstance().getString(ensurePath(m_path) + path);
    }
# 78 "include/framework/gearbox/GearDir.h"
    std::string getString(const std::string& path, const std::string& defaultValue) const
    {
      return gearbox::Interface::getString(path, defaultValue);
    }
# 94 "include/framework/gearbox/GearDir.h"
    virtual std::pair<std::string, std::string> getStringWithUnit(const std::string& path = "") const noexcept(false) override
    {
      return Gearbox::getInstance().getStringWithUnit(ensurePath(m_path) + path);
    }
# 108 "include/framework/gearbox/GearDir.h"
    virtual const TObject* getTObject(const std::string& path) const noexcept(false) override
    {
      return Gearbox::getInstance().getTObject(ensurePath(m_path) + path);
    }
  };

}
# 19 "klm/bklm/geometry/src/GeometryPar.cc" 2
# 1 "include/framework/logging/Logger.h" 1
# 11 "include/framework/logging/Logger.h"
# 1 "include/framework/logging/LogConfig.h" 1
# 11 "include/framework/logging/LogConfig.h"
namespace Belle2 {






  class LogConfig {
  public:


    enum ELogLevel { c_Debug,
                     c_Info,
                     c_Result,
                     c_Warning,
                     c_Error,
                     c_Fatal,
                     c_Default
                   };


    enum ELogInfo { c_Level = 0x01,
                    c_Message = 0x02,
                    c_Module = 0x04,
                    c_Package = 0x08,
                    c_Function = 0x10,
                    c_File = 0x20,
                    c_Line = 0x40,
                    c_Timestamp = 0x80,
                    c_NoVariables = 0x100,
                  };


    enum ELogRealm { c_None,
                     c_Online,
                     c_Production
                   };

    static const int c_DefaultDebugLevel = 10;







    explicit LogConfig(ELogLevel logLevel = c_Default, int debugLevel = c_DefaultDebugLevel);







    static const char* logLevelToString(ELogLevel logLevelType);







    static const char* logRealmToString(ELogRealm realm);






    void setLogLevel(ELogLevel logLevel);






    ELogLevel getLogLevel() const {return m_logLevel; }






    void setDebugLevel(int debugLevel) {m_debugLevel = debugLevel; }






    int getDebugLevel() const {return m_debugLevel; }






    void setAbortLevel(ELogLevel abortLevel) {m_abortLevel = abortLevel; }






    ELogLevel getAbortLevel() const {return m_abortLevel; }







    void setLogInfo(ELogLevel logLevel, unsigned int logInfo) {m_logInfo[logLevel] = logInfo; }






    unsigned int getLogInfo(ELogLevel logLevel) const {return m_logInfo[logLevel]; }


  private:

    ELogLevel m_logLevel;
    int m_debugLevel;
    ELogLevel m_abortLevel;

    unsigned int m_logInfo[c_Default];

  };

}
# 12 "include/framework/logging/Logger.h" 2
# 1 "include/framework/logging/LogMessage.h" 1
# 12 "include/framework/logging/LogMessage.h"
# 1 "include/framework/logging/LogVariableStream.h" 1
# 13 "include/framework/logging/LogVariableStream.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 1 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
    {
      struct __xfer_bufptrs;


      using allocator_traits = std::allocator_traits<_Alloc>;
      using _Noexcept_swap
 = __or_<typename allocator_traits::propagate_on_container_swap,
  typename allocator_traits::is_always_equal>;


    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

    protected:

      ios_base::openmode _M_mode;


      __string_type _M_string;

    public:
# 123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      basic_stringbuf()
      : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string()
      { }
# 134 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 147 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(),
 _M_string(__str.data(), __str.size(), __str.get_allocator())
      { _M_stringbuf_init(__mode); }


      basic_stringbuf(const basic_stringbuf&) = delete;

      basic_stringbuf(basic_stringbuf&& __rhs)
      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }


      explicit
      basic_stringbuf(const allocator_type& __a)
      : basic_stringbuf(ios_base::in | std::ios_base::out, __a)
      { }

      basic_stringbuf(ios_base::openmode __mode,
        const allocator_type& __a)
      : __streambuf_type(), _M_mode(__mode), _M_string(__a)
      { }

      explicit
      basic_stringbuf(__string_type&& __s,
        ios_base::openmode __mode = ios_base::in
        | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string(std::move(__s))
      { _M_stringbuf_init(__mode); }

      template<typename _SAlloc>
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   const allocator_type& __a)
 : basic_stringbuf(__s, ios_base::in | std::ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   ios_base::openmode __mode,
   const allocator_type& __a)
 : __streambuf_type(), _M_mode(__mode),
   _M_string(__s.data(), __s.size(), __a)
 { _M_stringbuf_init(__mode); }

      template<typename _SAlloc>
 explicit
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   ios_base::openmode __mode = ios_base::in
          | ios_base::out)
 : basic_stringbuf(__s, __mode, allocator_type{})
 { }

      basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a)
      : basic_stringbuf(std::move(__rhs), __a, __xfer_bufptrs(__rhs, this))
      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }

      allocator_type get_allocator() const noexcept
      { return _M_string.get_allocator(); }




      basic_stringbuf&
      operator=(const basic_stringbuf&) = delete;

      basic_stringbuf&
      operator=(basic_stringbuf&& __rhs)
      {
 __xfer_bufptrs __st{__rhs, this};
 const __streambuf_type& __base = __rhs;
 __streambuf_type::operator=(__base);
 this->pubimbue(__rhs.getloc());
 _M_mode = __rhs._M_mode;
 _M_string = std::move(__rhs._M_string);
 __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
 return *this;
      }

      void
      swap(basic_stringbuf& __rhs) noexcept(_Noexcept_swap::value)
      {
 __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
 __xfer_bufptrs __r_st{__rhs, this};
 __streambuf_type& __base = __rhs;
 __streambuf_type::swap(__base);
 __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
 std::swap(_M_mode, __rhs._M_mode);
 std::swap(_M_string, __rhs._M_string);
      }
# 250 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      [[__nodiscard__]]
      __string_type
      str() const &
      {
 __string_type __ret(_M_string.get_allocator());
 if (char_type* __hi = _M_high_mark())
   __ret.assign(this->pbase(), __hi);
 else
   __ret = _M_string;
 return __ret;
      }




      template<__allocator_like _SAlloc>
 [[__nodiscard__]]
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 {
   auto __sv = view();
   return { __sv.data(), __sv.size(), __sa };
 }


      [[__nodiscard__]]
      __string_type
      str() &&
      {
 if (char_type* __hi = _M_high_mark())
   {

     _M_string._M_set_length(_M_high_mark() - this->pbase());
   }
 auto __str = std::move(_M_string);
 _M_string.clear();
 _M_sync(_M_string.data(), 0, 0);
 return __str;
      }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      {
 if (char_type* __hi = _M_high_mark())
   return { this->pbase(), __hi };
 else
   return _M_string;
      }
# 309 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      void
      str(const __string_type& __s)
      {


 _M_string.assign(__s.data(), __s.size());
 _M_stringbuf_init(_M_mode);
      }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 {
   _M_string.assign(__s.data(), __s.size());
   _M_stringbuf_init(_M_mode);
 }


      void
      str(__string_type&& __s)
      {
 _M_string = std::move(__s);
 _M_stringbuf_init(_M_mode);
      }


    protected:

      void
      _M_stringbuf_init(ios_base::openmode __mode)
      {
 _M_mode = __mode;
 __size_type __len = 0;
 if (_M_mode & (ios_base::ate | ios_base::app))
   __len = _M_string.size();
 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
      }

      virtual streamsize
      showmanyc()
      {
 streamsize __ret = -1;
 if (_M_mode & ios_base::in)
   {
     _M_update_egptr();
     __ret = this->egptr() - this->gptr();
   }
 return __ret;
      }

      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = traits_type::eof());

      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 382 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
 if (__s && __n >= 0)
   {






     _M_string.clear();


     _M_sync(__s, __n, 0);
   }
 return this;
      }

      virtual pos_type
      seekoff(off_type __off, ios_base::seekdir __way,
       ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual pos_type
      seekpos(pos_type __sp,
       ios_base::openmode __mode = ios_base::in | ios_base::out);




      void
      _M_sync(char_type* __base, __size_type __i, __size_type __o);



      void
      _M_update_egptr()
      {
 if (char_type* __pptr = this->pptr())
   {
     char_type* __egptr = this->egptr();
     if (!__egptr || __pptr > __egptr)
       {
  if (_M_mode & ios_base::in)
    this->setg(this->eback(), this->gptr(), __pptr);
  else
    this->setg(__pptr, __pptr, __pptr);
       }
   }
      }



      void
      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);

    private:




      __attribute__((__always_inline__))
      char_type*
      _M_high_mark() const noexcept
      {
 if (char_type* __pptr = this->pptr())
   {
     char_type* __egptr = this->egptr();
     if (!__egptr || __pptr > __egptr)
       return __pptr;
     else
       return __egptr;
   }
 return 0;
      }





      struct __xfer_bufptrs
      {
 __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
 : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
 {
   const _CharT* const __str = __from._M_string.data();
   const _CharT* __end = nullptr;
   if (__from.eback())
     {
       _M_goff[0] = __from.eback() - __str;
       _M_goff[1] = __from.gptr() - __str;
       _M_goff[2] = __from.egptr() - __str;
       __end = __from.egptr();
     }
   if (__from.pbase())
     {
       _M_poff[0] = __from.pbase() - __str;
       _M_poff[1] = __from.pptr() - __from.pbase();
       _M_poff[2] = __from.epptr() - __str;
       if (!__end || __from.pptr() > __end)
  __end = __from.pptr();
     }


   if (__end)
     {


       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
       __mut_from._M_string._M_length(__end - __str);
     }
 }

 ~__xfer_bufptrs()
 {
   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
   if (_M_goff[0] != -1)
     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
   if (_M_poff[0] != -1)
     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
 }

 basic_stringbuf* _M_to;
 off_type _M_goff[3];
 off_type _M_poff[3];
      };
# 518 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
      { }




      basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a,
        __xfer_bufptrs&&)
      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string), __a)
      { }


    };
# 551 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 585 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      basic_istringstream()
      : __istream_type(), _M_stringbuf(ios_base::in)
      { this->init(&_M_stringbuf); }
# 601 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 619 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_istringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
      { this->init(&_M_stringbuf); }







      ~basic_istringstream()
      { }


      basic_istringstream(const basic_istringstream&) = delete;

      basic_istringstream(basic_istringstream&& __rhs)
      : __istream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __istream_type::set_rdbuf(&_M_stringbuf); }


      basic_istringstream(ios_base::openmode __mode, const allocator_type& __a)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in, __a)
      { this->init(std::__addressof(_M_stringbuf)); }

      explicit
      basic_istringstream(__string_type&& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::in)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       const allocator_type& __a)
 : basic_istringstream(__str, ios_base::in, __a)
 { }

      template<typename _SAlloc>
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode,
       const allocator_type& __a)
 : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode = ios_base::in)
 : basic_istringstream(__str, __mode, allocator_type())
 { }




      basic_istringstream&
      operator=(const basic_istringstream&) = delete;

      basic_istringstream&
      operator=(basic_istringstream&& __rhs)
      {
 __istream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_istringstream& __rhs)
      {
 __istream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 702 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      [[__nodiscard__]]
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      [[__nodiscard__]]
      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 [[__nodiscard__]]
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      [[__nodiscard__]]
      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 744 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };
# 779 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 813 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      basic_ostringstream()
      : __ostream_type(), _M_stringbuf(ios_base::out)
      { this->init(&_M_stringbuf); }
# 829 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 847 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_ostringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
      { this->init(&_M_stringbuf); }







      ~basic_ostringstream()
      { }


      basic_ostringstream(const basic_ostringstream&) = delete;

      basic_ostringstream(basic_ostringstream&& __rhs)
      : __ostream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __ostream_type::set_rdbuf(&_M_stringbuf); }


      basic_ostringstream(ios_base::openmode __mode, const allocator_type& __a)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out, __a)
      { this->init(std::__addressof(_M_stringbuf)); }

      explicit
      basic_ostringstream(__string_type&& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::out)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       const allocator_type& __a)
 : basic_ostringstream(__str, ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode,
       const allocator_type& __a)
 : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode = ios_base::out)
 : basic_ostringstream(__str, __mode, allocator_type())
 { }




      basic_ostringstream&
      operator=(const basic_ostringstream&) = delete;

      basic_ostringstream&
      operator=(basic_ostringstream&& __rhs)
      {
 __ostream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_ostringstream& __rhs)
      {
 __ostream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 930 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      [[__nodiscard__]]
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      [[__nodiscard__]]
      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 [[__nodiscard__]]
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      [[__nodiscard__]]
      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 972 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };
# 1007 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 1041 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      basic_stringstream()
      : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in)
      { this->init(&_M_stringbuf); }
# 1055 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 1071 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      explicit
      basic_stringstream(const __string_type& __str,
    ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__str, __m)
      { this->init(&_M_stringbuf); }







      ~basic_stringstream()
      { }


      basic_stringstream(const basic_stringstream&) = delete;

      basic_stringstream(basic_stringstream&& __rhs)
      : __iostream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __iostream_type::set_rdbuf(&_M_stringbuf); }


      basic_stringstream(ios_base::openmode __mode, const allocator_type& __a)
      : __iostream_type(), _M_stringbuf(__mode, __a)
      { this->init(&_M_stringbuf); }

      explicit
      basic_stringstream(__string_type&& __str,
    ios_base::openmode __mode = ios_base::in
           | ios_base::out)
      : __iostream_type(), _M_stringbuf(std::move(__str), __mode)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      const allocator_type& __a)
 : basic_stringstream(__str, ios_base::in | ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      ios_base::openmode __mode,
      const allocator_type& __a)
 : __iostream_type(), _M_stringbuf(__str, __mode, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      ios_base::openmode __mode = ios_base::in
             | ios_base::out)
 : basic_stringstream(__str, __mode, allocator_type())
 { }




      basic_stringstream&
      operator=(const basic_stringstream&) = delete;

      basic_stringstream&
      operator=(basic_stringstream&& __rhs)
      {
 __iostream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_stringstream& __rhs)
      {
 __iostream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 1156 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      [[__nodiscard__]]
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      [[__nodiscard__]]
      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 [[__nodiscard__]]
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      [[__nodiscard__]]
      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 1198 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };



  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


}

}




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/sstream.tcc" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/sstream.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{


  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      if (this->eback() < this->gptr())
 {


   const bool __testeof = traits_type::eq_int_type(__c, __ret);
   if (!__testeof)
     {
       const bool __testeq = traits_type::eq(traits_type::
          to_char_type(__c),
          this->gptr()[-1]);
       const bool __testout = this->_M_mode & ios_base::out;
       if (__testeq || __testout)
  {
    this->gbump(-1);
    if (!__testeq)
      *this->gptr() = traits_type::to_char_type(__c);
    __ret = __c;
  }
     }
   else
     {
       this->gbump(-1);
       __ret = traits_type::not_eof(__c);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();


      if (size_t(this->epptr() - this->pbase()) < __capacity)
 {

   char_type* __base = const_cast<char_type*>(_M_string.data());
   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
   if (_M_mode & ios_base::in)
     {
       const __size_type __nget = this->gptr() - this->eback();
       const __size_type __eget = this->egptr() - this->eback();
       this->setg(__base, __base + __nget, __base + __eget + 1);
     }
   *this->pptr() = traits_type::to_char_type(__c);
   this->pbump(1);
   return __c;
 }


      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      const char_type __conv = traits_type::to_char_type(__c);
      if (!__testput)
 {
# 133 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;




}

#pragma GCC diagnostic pop
# 1256 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/sstream" 2 3
# 14 "include/framework/logging/LogVariableStream.h" 2




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast.hpp" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/buffer_view.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/buffer_view.hpp" 3
namespace boost { namespace conversion { namespace detail {

    template < typename CharT >
    struct buffer_view {
        const CharT* begin;
        const CharT* end;
    };

    template < typename CharT >
    buffer_view<CharT> make_buffer_view(const CharT* begin, const CharT* end) {
        return buffer_view<CharT>{begin, end};
    }

    inline buffer_view<char> make_buffer_view(const signed char* begin, const signed char* end) {
        return buffer_view<char>{
            reinterpret_cast<const char*>(begin),
            reinterpret_cast<const char*>(end)
        };
    }

    inline buffer_view<char> make_buffer_view(const unsigned char* begin, const unsigned char* end) {
        return buffer_view<char>{
            reinterpret_cast<const char*>(begin),
            reinterpret_cast<const char*>(end)
        };
    }

    template< typename CharT, typename Elem, typename Traits >
    std::basic_ostream<Elem,Traits>& operator<<(
                std::basic_ostream<Elem, Traits>& os,
                buffer_view<CharT> r)
    {
        while (r.begin != r.end) {
          os << r.begin[0];
          ++r.begin;
        }
        return os;
    }

}}}
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/bad_lexical_cast.hpp" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/bad_lexical_cast.hpp" 3
namespace boost
{

    class __attribute__((__visibility__("default"))) bad_lexical_cast :




        public std::bad_cast

    {
    public:
        bad_lexical_cast() noexcept

           : source(&typeid(void)), target(&typeid(void))

        {}

        const char *what() const noexcept override {
            return "bad lexical cast: "
                   "source type value could not be interpreted as target";
        }

        bad_lexical_cast(const bad_lexical_cast&) = default;
        bad_lexical_cast& operator=(const bad_lexical_cast&) = default;


    private:



        typedef ::std::type_info type_info_t;

    public:
        bad_lexical_cast(
                const type_info_t &source_type_arg,
                const type_info_t &target_type_arg) noexcept
            : source(&source_type_arg), target(&target_type_arg)
        {}

        const type_info_t &source_type() const noexcept {
            return *source;
        }

        const type_info_t &target_type() const noexcept {
            return *target;
        }

    private:
        const type_info_t *source;
        const type_info_t *target;

    };

    namespace conversion { namespace detail {






        template <class S, class T>
        inline void throw_bad_cast() {
            boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
        }

    }}

}
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/try_lexical_convert.hpp" 1 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/try_lexical_convert.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/is_character.hpp" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/is_character.hpp" 3
namespace boost { namespace detail {


template < typename T >
using is_character = std::integral_constant<
    bool,
    std::is_same< T, char >::value ||

    std::is_same< T, wchar_t >::value ||


    std::is_same< T, char16_t >::value ||


    std::is_same< T, char32_t >::value ||

    std::is_same< T, unsigned char >::value ||
    std::is_same< T, signed char >::value
>;

}}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_numeric.hpp" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_numeric.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/cmath.hpp" 1 3
# 121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/cmath.hpp" 3
namespace boost
{
namespace core
{
# 238 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/cmath.hpp" 3
using std::isfinite;
using std::isnan;
using std::isinf;
using std::isnormal;
using std::fpclassify;

int const fp_zero = 2;
int const fp_subnormal = 3;
int const fp_normal = 4;
int const fp_infinite = 1;
int const fp_nan = 0;

using std::signbit;
# 263 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/cmath.hpp" 3
namespace detail
{



inline float copysign_impl( float x, float y )
{
    return __builtin_copysignf( x, y );
}

inline double copysign_impl( double x, double y )
{
    return __builtin_copysign( x, y );
}

inline long double copysign_impl( long double x, long double y )
{
    return __builtin_copysignl( x, y );
}

}

template<class T> T copysign( T x, T y )
{
    return boost::core::detail::copysign_impl( x, y );
}




}
}
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_numeric.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/type_traits.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/type_traits.hpp" 3
namespace boost { namespace detail { namespace lcast {






template<class T> struct is_integral: public std::is_integral<T>
{
};

template<class T> struct is_signed: public std::is_signed<T>
{
};

template<class T> struct is_unsigned: public std::is_unsigned<T>
{
};

template<class T> struct make_unsigned: public std::make_unsigned<T>
{
};



template<> struct is_integral<__int128_t>: public std::true_type
{
};

template<> struct is_integral<__uint128_t>: public std::true_type
{
};

template<> struct is_signed<__int128_t>: public std::true_type
{
};

template<> struct is_signed<__uint128_t>: public std::false_type
{
};

template<> struct is_unsigned<__int128_t>: public std::false_type
{
};

template<> struct is_unsigned<__uint128_t>: public std::true_type
{
};

template<> struct make_unsigned<__int128_t>
{
    typedef __uint128_t type;
};

template<> struct make_unsigned<__uint128_t>
{
    typedef __uint128_t type;
};



}}}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_numeric.hpp" 2 3

namespace boost { namespace detail {

template <class Source, class Target>
bool ios_numeric_comparer_float(Source x, Source y) noexcept {
    return x == y
        || (boost::core::isnan(x) && boost::core::isnan(y))
        || (x < (std::numeric_limits<Target>::min)())
    ;
}

template <class RangeType, class T>
constexpr bool is_out_of_range_for(T value) noexcept {
    return value > static_cast<T>((std::numeric_limits<RangeType>::max)())
        || value < static_cast<T>((std::numeric_limits<RangeType>::min)())
        || boost::core::isnan(value);
}



template <typename Target, typename Source>
typename std::enable_if<
    !std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
    const Target target_tmp = static_cast<Target>(arg);
    const Source arg_restored = static_cast<Source>(target_tmp);
    if (arg == arg_restored) {
        result = target_tmp;
        return true;
    }
    return false;
}


template <typename Target, typename Source>
typename std::enable_if<
    !std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
    const Target target_tmp = static_cast<Target>(arg);
    result = target_tmp;
    return true;
}



template <typename Target, typename Source>
typename std::enable_if<
    std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
    const Target target_tmp = static_cast<Target>(arg);
    const Source arg_restored = static_cast<Source>(target_tmp);
    if (detail::ios_numeric_comparer_float<Source, Target>(arg, arg_restored)) {
        result = target_tmp;
        return true;
    }

    return false;
}


template <typename Target, typename Source>
typename std::enable_if<
    std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
>::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
    if (detail::is_out_of_range_for<Target>(arg)) {
        return false;
    }

    const Target target_tmp = static_cast<Target>(arg);
    const Source arg_restored = static_cast<Source>(target_tmp);
    if (arg == arg_restored ) {
        result = target_tmp;
        return true;
    }

    return false;
}

struct lexical_cast_dynamic_num_not_ignoring_minus
{
    template <typename Target, typename Source>
    static inline bool try_convert(Source arg, Target& result) noexcept {
        return boost::detail::noexcept_numeric_convert<Target, Source >(arg, result);
    }
};

struct lexical_cast_dynamic_num_ignoring_minus
{
    template <typename Target, typename Source>

    __attribute__((no_sanitize("unsigned-integer-overflow")))

    static inline bool try_convert(Source arg, Target& result) noexcept {
        typedef typename std::conditional<
                std::is_floating_point<Source>::value,
                std::conditional<true, Source, Source>,
                boost::detail::lcast::make_unsigned<Source>
        >::type usource_lazy_t;
        typedef typename usource_lazy_t::type usource_t;

        if (arg < 0) {
            const bool res = boost::detail::noexcept_numeric_convert<Target, usource_t>(
                static_cast<usource_t>(0u - static_cast<usource_t>(arg)), result
            );
            result = static_cast<Target>(0u - result);
            return res;
        } else {
            return boost::detail::noexcept_numeric_convert<Target, usource_t>(arg, result);
        }
    }
};
# 160 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_numeric.hpp" 3
template <typename Target, typename Source>
struct dynamic_num_converter_impl
{
    static inline bool try_convert(Source arg, Target& result) noexcept {
        typedef typename std::conditional<
            boost::detail::lcast::is_unsigned<Target>::value &&
            (boost::detail::lcast::is_signed<Source>::value || std::is_floating_point<Source>::value) &&
            !(std::is_same<Source, bool>::value) &&
            !(std::is_same<Target, bool>::value),
            lexical_cast_dynamic_num_ignoring_minus,
            lexical_cast_dynamic_num_not_ignoring_minus
        >::type caster_type;

        return caster_type::try_convert(arg, result);
    }
};

}}
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 1 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/lcast_precision.hpp" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/lcast_precision.hpp" 3
namespace boost { namespace detail {



template<class T>
struct lcast_precision
{
    using limits = std::numeric_limits<T>;

    static constexpr bool use_default_precision =
            !limits::is_specialized || limits::is_exact
        ;

    static constexpr bool is_specialized_bin =
            !use_default_precision &&
            limits::radix == 2 && limits::digits > 0
        ;

    static constexpr bool is_specialized_dec =
            !use_default_precision &&
            limits::radix == 10 && limits::digits10 > 0
        ;

    static constexpr std::streamsize streamsize_max =
            (std::numeric_limits<std::streamsize>::max)()
        ;

    static constexpr unsigned int precision_dec = limits::digits10 + 1U;

    static_assert(!is_specialized_dec ||
            precision_dec <= streamsize_max + 0UL
        , "");

    static constexpr unsigned long precision_bin =
            2UL + limits::digits * 30103UL / 100000UL
        ;

    static_assert(!is_specialized_bin ||
            (limits::digits + 0UL < (9223372036854775807L *2UL+1UL) / 30103UL &&
            precision_bin > limits::digits10 + 0UL &&
            precision_bin <= streamsize_max + 0UL)
        , "");

    static constexpr std::streamsize value =
            is_specialized_bin ? precision_bin
                               : is_specialized_dec ? precision_dec : 6
        ;
};

template<class T>
inline void lcast_set_precision(std::ios_base& stream, T*)
{
    stream.precision(lcast_precision<T>::value);
}

template<class Source, class Target>
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
{
    std::streamsize const s = lcast_precision<Source>::value;
    std::streamsize const t = lcast_precision<Target*>::value;
    stream.precision(s > t ? s : t);
}

}}
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/widest_char.hpp" 1 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/widest_char.hpp" 3
namespace boost { namespace detail {

template <typename TargetChar, typename SourceChar>
using widest_char = std::conditional<
    (sizeof(TargetChar) > sizeof(SourceChar))
    , TargetChar
    , SourceChar
>;

}}
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/workaround.hpp" 1 3
# 158 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/workaround.hpp" 3
namespace boost {
namespace container {

template <typename T1>
inline __attribute__ ((__always_inline__)) constexpr void ignore(T1 const&)
{}

}}
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 2 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/std_fwd.hpp" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/std_fwd.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/move/detail/std_ns_begin.hpp" 1 3
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/std_fwd.hpp" 2 3
namespace std __attribute__ ((__visibility__ ("default"))) {

template<class T>
class allocator;

template<class T>
struct less;

template<class T>
struct equal_to;

template<class T1, class T2>
struct pair;

template<class T>
struct char_traits;

struct input_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;

template<class Container>
class insert_iterator;

struct allocator_arg_t;

struct piecewise_construct_t;

template <class Ptr>
struct pointer_traits;

 }
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/move/detail/std_ns_end.hpp" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/detail/std_fwd.hpp" 2 3




namespace std {

enum class align_val_t : std::size_t;

}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 2 3


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;
}}}
# 92 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/container/container_fwd.hpp" 3
namespace boost {
namespace container {



template<class T>
class new_allocator;

template <class T
         ,class Allocator = void
         ,class Options = void>
class vector;

template <class T
         ,class Allocator = void >
class stable_vector;

template < class T
         , std::size_t Capacity
         , class Options = void>
class static_vector;

template < class T
         , class Allocator = void
         , class Options = void >
class small_vector_base;

template < class T
         , std::size_t N
         , class Allocator = void
         , class Options = void >
class small_vector;

template <class T
         ,class Allocator = void
         ,class Options = void>
class devector;

template <class T
         ,class Allocator = void
         ,class Options = void>
class deque;

template <class T
         ,class Allocator = void >
class list;

template <class T
         ,class Allocator = void >
class slist;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void>
class set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class multimap;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_multimap;





template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_set = flat_set<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_multiset = flat_multiset<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_map = flat_map<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_multimap = flat_multimap<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions>>;





template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_set_of
{
   typedef flat_set<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_multiset_of
{
   typedef flat_multiset<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_map_of
{
   typedef flat_map<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_multimap_of
{
   typedef flat_multimap<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions> > type;
};

template <class CharT
         ,class Traits = std::char_traits<CharT>
         ,class Allocator = void >
class basic_string;

typedef basic_string <char> string;
typedef basic_string<wchar_t> wstring;

static constexpr std::size_t ADP_nodes_per_block = 256u;
static constexpr std::size_t ADP_max_free_blocks = 2u;
static constexpr std::size_t ADP_overhead_percent = 1u;
static constexpr 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 constexpr 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
{};



inline constexpr ordered_range_t ordered_range = ordered_range_t();



struct ordered_unique_range_t
   : public ordered_range_t
{};



inline constexpr ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();



struct default_init_t
{};



inline constexpr default_init_t default_init = default_init_t();




struct value_init_t
{};



inline constexpr value_init_t value_init = value_init_t();

namespace container_detail_really_deep_namespace {



struct dummy
{
   dummy()
   {
      (void)ordered_range;
      (void)ordered_unique_range;
      (void)default_init;
   }
};

}

typedef const std::piecewise_construct_t & piecewise_construct_t;



}}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/snprintf.hpp" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/snprintf.hpp" 3
namespace boost {

namespace core {
# 161 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/snprintf.hpp" 3
using ::snprintf;
using ::vsnprintf;

using ::swprintf;
using ::vswprintf;



}

}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_char_constants.hpp" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_char_constants.hpp" 3
namespace boost
{
    namespace detail
    {
        template < typename Char >
        struct lcast_char_constants {


            static const Char zero = static_cast<Char>('0');
            static const Char minus = static_cast<Char>('-');
            static const Char plus = static_cast<Char>('+');
            static const Char lowercase_e = static_cast<Char>('e');
            static const Char capital_e = static_cast<Char>('E');
            static const Char c_decimal_separator = static_cast<Char>('.');
        };
    }
}
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/noncopyable.hpp" 1 3
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/noncopyable.hpp" 3
namespace boost {






namespace noncopyable_
{
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/core/noncopyable.hpp" 3
  struct base_token {};



  class noncopyable: base_token
  {
  protected:

      constexpr noncopyable() = default;
      ~noncopyable() = default;





      noncopyable( const noncopyable& ) = delete;
      noncopyable& operator=( const noncopyable& ) = delete;





  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 2 3

namespace boost
{
    namespace detail
    {
        template<class T>

       __attribute__((no_sanitize("unsigned-integer-overflow")))

        inline
        typename boost::detail::lcast::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
            typedef typename boost::detail::lcast::make_unsigned<T>::type result_type;
            return value < 0
                ? static_cast<result_type>(0u - static_cast<result_type>(value))
                : static_cast<result_type>(value);
        }
    }

    namespace detail
    {
        template <class Traits, class T, class CharT>
        class lcast_put_unsigned: boost::noncopyable {
            typedef typename Traits::int_type int_type;
            typename std::conditional<
                    (sizeof(unsigned) > sizeof(T))
                    , unsigned
                    , T
            >::type m_value;
            CharT* m_finish;
            CharT const m_czero;
            int_type const m_zero;

        public:
            lcast_put_unsigned(const T n_param, CharT* finish) noexcept
                : m_value(n_param), m_finish(finish)
                , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
            {

                static_assert(!std::numeric_limits<T>::is_signed, "");

            }

            CharT* convert() {

                std::locale loc;
                if (loc == std::locale::classic()) {
                    return main_convert_loop();
                }

                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();

                if (!grouping_size || grouping[0] <= 0) {
                    return main_convert_loop();
                }



                static_assert(std::numeric_limits<T>::digits10 < 127, "");

                CharT const thousands_sep = np.thousands_sep();
                std::string::size_type group = 0;
                char last_grp_size = grouping[0];
                char left = last_grp_size;

                do {
                    if (left == 0) {
                        ++group;
                        if (group < grouping_size) {
                            char const grp_size = grouping[group];
                            last_grp_size = (grp_size <= 0 ? static_cast<char>(127) : grp_size);
                        }

                        left = last_grp_size;
                        --m_finish;
                        Traits::assign(*m_finish, thousands_sep);
                    }

                    --left;
                } while (main_convert_iteration());

                return m_finish;



            }

        private:
            inline bool main_convert_iteration() noexcept {
                --m_finish;
                int_type const digit = static_cast<int_type>(m_value % 10U);
                Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
                m_value /= 10;
                return !!m_value;
            }

            inline CharT* main_convert_loop() noexcept {
                while (main_convert_iteration());
                return m_finish;
            }
        };
    }

    namespace detail
    {
        template <class Traits, class T, class CharT>
        class lcast_ret_unsigned: boost::noncopyable {
            bool m_multiplier_overflowed;
            T m_multiplier;
            T& m_value;
            const CharT* const m_begin;
            const CharT* m_end;

        public:
            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) noexcept
                : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
            {

                static_assert(!std::numeric_limits<T>::is_signed, "");






                static_assert(std::numeric_limits<T>::is_specialized,
                    "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
                );

            }

            inline bool convert() {
                CharT const czero = lcast_char_constants<CharT>::zero;
                --m_end;
                m_value = static_cast<T>(0);

                if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
                    return false;
                m_value = static_cast<T>(*m_end - czero);
                --m_end;




                std::locale loc;
                if (loc == std::locale::classic()) {
                    return main_convert_loop();
                }

                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const& grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();




                if (!grouping_size || grouping[0] <= 0) {
                    return main_convert_loop();
                }

                unsigned char current_grouping = 0;
                CharT const thousands_sep = np.thousands_sep();
                char remained = static_cast<char>(grouping[current_grouping] - 1);

                for (;m_end >= m_begin; --m_end)
                {
                    if (remained) {
                        if (!main_convert_iteration()) {
                            return false;
                        }
                        --remained;
                    } else {
                        if ( !Traits::eq(*m_end, thousands_sep) )
                        {
# 240 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 3
                            return main_convert_loop();
                        } else {
                            if (m_begin == m_end) return false;
                            if (current_grouping < grouping_size - 1) ++current_grouping;
                            remained = grouping[current_grouping];
                        }
                    }
                }

                return true;

            }

        private:



            __attribute__((no_sanitize("unsigned-integer-overflow")))

            inline bool main_convert_iteration() noexcept {
                CharT const czero = lcast_char_constants<CharT>::zero;
                T const maxv = (std::numeric_limits<T>::max)();

                m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
                m_multiplier = static_cast<T>(m_multiplier * 10);

                T const dig_value = static_cast<T>(*m_end - czero);
                T const new_sub_value = static_cast<T>(m_multiplier * dig_value);



                if (*m_end < czero || *m_end >= czero + 10
                    || (dig_value && (
                        m_multiplier_overflowed
                        || static_cast<T>(maxv / dig_value) < m_multiplier
                        || static_cast<T>(maxv - new_sub_value) < m_value
                    ))
                ) return false;

                m_value = static_cast<T>(m_value + new_sub_value);

                return true;
            }

            bool main_convert_loop() noexcept {
                for ( ; m_end >= m_begin; --m_end) {
                    if (!main_convert_iteration()) {
                        return false;
                    }
                }

                return true;
            }
        };
    }
}
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/basic_pointerbuf.hpp" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/detail/basic_pointerbuf.hpp" 3
namespace boost { namespace detail {





template <class charT, class BufferT >
class basic_pointerbuf : public BufferT {
protected:
   typedef BufferT base_type;
   typedef basic_pointerbuf<charT, BufferT> this_type;
   typedef typename base_type::int_type int_type;
   typedef typename base_type::char_type char_type;
   typedef typename base_type::pos_type pos_type;
   typedef ::std::streamsize streamsize;
   typedef typename base_type::off_type off_type;

public:
   basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
   const charT* getnext() { return this->gptr(); }

    using base_type::pptr;
    using base_type::pbase;

protected:




   inline base_type* setbuf(char_type* s, streamsize n) override;
   inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) override;
   inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) override;

private:
   basic_pointerbuf& operator=(const basic_pointerbuf&);
   basic_pointerbuf(const basic_pointerbuf&);
};

template<class charT, class BufferT>
BufferT*
basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
{
   this->setg(s, s, s + n);
   return this;
}

template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
{
   typedef ::std::ios_base::seekdir cast_type;

   if(which & ::std::ios_base::out)
      return pos_type(off_type(-1));
   std::ptrdiff_t size = this->egptr() - this->eback();
   std::ptrdiff_t pos = this->gptr() - this->eback();
   charT* g = this->eback();
   switch(static_cast<cast_type>(way))
   {
   case ::std::ios_base::beg:
      if((off < 0) || (off > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + off, g + size);
      break;
   case ::std::ios_base::end:
      if((off < 0) || (off > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + size - off, g + size);
      break;
   case ::std::ios_base::cur:
   {
      std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
      if((newpos < 0) || (newpos > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + newpos, g + size);
      break;
   }
   default: ;
   }




   return static_cast<pos_type>(this->gptr() - this->eback());



}

template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
{
   if(which & ::std::ios_base::out)
      return pos_type(off_type(-1));
   off_type size = static_cast<off_type>(this->egptr() - this->eback());
   charT* g = this->eback();
   if(off_type(sp) <= size)
   {
      this->setg(g, g + off_type(sp), g + size);
   }
   return pos_type(off_type(-1));
}

}}
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp" 2 3




namespace boost { namespace detail { namespace lcast {



    template <class BufferType, class CharT>
    class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
    public:
        typedef basic_pointerbuf<CharT, BufferType> base_type;
        typedef typename base_type::streamsize streamsize;

        using base_type::pptr;
        using base_type::pbase;
        using base_type::setbuf;
    };
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp" 3
    template <class CharT, class Traits>
    using out_stream_t = std::basic_ostream<CharT, Traits>;

    template <class CharT, class Traits>
    using stringbuffer_t = basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT>;

    template <class CharT, class Traits>
    using buffer_t = basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>;


}}}
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/inf_nan.hpp" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/inf_nan.hpp" 3
namespace boost {
    namespace detail
    {
        template <class CharT>
        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
            for( unsigned int i=0; i < len; ++i ) {
                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
            }

            return true;
        }


        template <class CharT, class T>
        inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
            , const CharT* lc_NAN, const CharT* lc_nan
            , const CharT* lc_INFINITY, const CharT* lc_infinity
            , const CharT opening_brace, const CharT closing_brace) noexcept
        {
            if (begin == end) return false;
            const CharT minus = lcast_char_constants<CharT>::minus;
            const CharT plus = lcast_char_constants<CharT>::plus;
            const int inifinity_size = 8;


            bool const has_minus = (*begin == minus);
            if (has_minus || *begin == plus) {
                ++ begin;
            }

            if (end - begin < 3) return false;
            if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
                begin += 3;
                if (end != begin) {


                    if (end - begin < 2) return false;
                    -- end;
                    if (*begin != opening_brace || *end != closing_brace) return false;
                }

                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
                else value = boost::core::copysign(std::numeric_limits<T>::quiet_NaN(), static_cast<T>(-1));
                return true;
            } else if (
                (
                  end - begin == 3
                  && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
                )
                ||
                (
                  end - begin == inifinity_size
                  && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
                )
             )
            {
                if( !has_minus ) value = std::numeric_limits<T>::infinity();
                else value = -std::numeric_limits<T>::infinity();
                return true;
            }

            return false;
        }

        template <class CharT, class T>
        const CharT* get_inf_nan_impl(T value
                         , const CharT* lc_nan
                         , const CharT* lc_minus_nan
                         , const CharT* lc_infinity
                         , const CharT* lc_minus_infinity) noexcept
        {
            if (boost::core::isnan(value)) {
                if (boost::core::signbit(value)) {
                    return lc_minus_nan;
                }
                return lc_nan;
            } else if (boost::core::isinf(value)) {
                if (boost::core::signbit(value)) {
                    return lc_minus_infinity;
                }
                return lc_infinity;
            }

            return nullptr;
        }



        template <class T>
        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , L"NAN", L"nan"
                               , L"INFINITY", L"infinity"
                               , L'(', L')');
        }

        template <class T>
        const wchar_t* get_inf_nan(T value, wchar_t) noexcept {
            return detail::get_inf_nan_impl(value, L"nan", L"-nan", L"inf", L"-inf");
        }



        template <class T>
        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , u"NAN", u"nan"
                               , u"INFINITY", u"infinity"
                               , u'(', u')');
        }

        template <class T>
        const char16_t* get_inf_nan(T value, char16_t) noexcept {
            return detail::get_inf_nan_impl(value, u"nan", u"-nan", u"inf", u"-inf");
        }


        template <class T>
        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , U"NAN", U"nan"
                               , U"INFINITY", U"infinity"
                               , U'(', U')');
        }

        template <class T>
        const char32_t* get_inf_nan(T value, char32_t) noexcept {
            return detail::get_inf_nan_impl(value, U"nan", U"-nan", U"inf", U"-inf");
        }


        template <class CharT, class T>
        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , "NAN", "nan"
                               , "INFINITY", "infinity"
                               , '(', ')');
        }

        template <class T>
        const char* get_inf_nan(T value, char) noexcept {
            return detail::get_inf_nan_impl(value, "nan", "-nan", "inf", "-inf");
        }
    }
}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3
namespace boost {
    template<class T, std::size_t N>
    class array;
    template<class IteratorT>
    class iterator_range;


    template<class Ch, class Tr> class basic_string_view;
}

namespace boost { namespace detail { namespace lcast {

    template <typename T>
    struct exact {
        static_assert(!std::is_const<T>::value, "");
        static_assert(!std::is_reference<T>::value, "");

        const T& payload;
    };

    template< class CharT
            , class Traits
            , std::size_t CharacterBufferSize
            >
    class optimized_src_stream {
        CharT buffer[CharacterBufferSize];



        const CharT* start;
        const CharT* finish;
    public:
        optimized_src_stream(optimized_src_stream&&) = delete;
        optimized_src_stream(const optimized_src_stream&) = delete;
        optimized_src_stream& operator=(optimized_src_stream&&) = delete;
        optimized_src_stream& operator=(const optimized_src_stream&) = delete;

        optimized_src_stream() noexcept
          : start(buffer)
          , finish(buffer + CharacterBufferSize)
        {}

        const CharT* cbegin() const noexcept {
            return start;
        }

        const CharT* cend() const noexcept {
            return finish;
        }

    private:
        bool shl_char(CharT ch) noexcept {
            Traits::assign(buffer[0], ch);
            finish = start + 1;
            return true;
        }


        template <class T>
        bool shl_char(T ch) {
            static_assert(sizeof(T) <= sizeof(CharT),
                "boost::lexical_cast does not support narrowing of char types."
                "Use boost::locale instead" );

            std::locale loc;
            CharT const w = std::use_facet< std::ctype<CharT> >(loc).widen(ch);



            Traits::assign(buffer[0], w);
            finish = start + 1;
            return true;
        }


        bool shl_char_array(CharT const* str_value) noexcept {
            start = str_value;
            finish = start + Traits::length(str_value);
            return true;
        }

        bool shl_char_array_limited(CharT const* str, std::size_t max_size) noexcept {
            start = str;
            finish = start;
            const auto zero = Traits::to_char_type(0);
            while (finish < start + max_size && zero != *finish) {
                 ++ finish;
            }
            return true;
        }

        template <class T>
        inline bool shl_unsigned(const T n) {
            CharT* tmp_finish = buffer + CharacterBufferSize;
            start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
            finish = tmp_finish;
            return true;
        }

        template <class T>
        inline bool shl_signed(const T n) {
            CharT* tmp_finish = buffer + CharacterBufferSize;
            typedef typename boost::detail::lcast::make_unsigned<T>::type utype;
            CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
            if (n < 0) {
                --tmp_start;
                CharT const minus = lcast_char_constants<CharT>::minus;
                Traits::assign(*tmp_start, minus);
            }
            start = tmp_start;
            finish = tmp_finish;
            return true;
        }

        bool shl_real_type(lcast::exact<float> val, char* begin) {
            const double val_as_double = static_cast<double>(val.payload);
            finish = start +
                boost::core::snprintf(begin, CharacterBufferSize,
                "%.*g", static_cast<int>(boost::detail::lcast_precision<float>::value), val_as_double);
            return finish > start;
        }

        bool shl_real_type(lcast::exact<double> val, char* begin) {
            finish = start +
                boost::core::snprintf(begin, CharacterBufferSize,
                "%.*g", static_cast<int>(boost::detail::lcast_precision<double>::value), val.payload);
            return finish > start;
        }


        bool shl_real_type(lcast::exact<long double> val, char* begin) {
            finish = start +
                boost::core::snprintf(begin, CharacterBufferSize,
                "%.*Lg", static_cast<int>(boost::detail::lcast_precision<long double>::value), val.payload );
            return finish > start;
        }







        bool shl_real_type(lcast::exact<float> val, wchar_t* begin) {
            const double val_as_double = static_cast<double>(val.payload);
            finish = start + boost::core::swprintf(
                begin, CharacterBufferSize, L"%.*g",
                static_cast<int>(boost::detail::lcast_precision<float>::value),
                val_as_double
            );
            return finish > start;
        }

        bool shl_real_type(lcast::exact<double> val, wchar_t* begin) {
            finish = start + boost::core::swprintf(
              begin, CharacterBufferSize, L"%.*g",
              static_cast<int>(boost::detail::lcast_precision<double>::value),
              val.payload
            );
            return finish > start;
        }

        bool shl_real_type(lcast::exact<long double> val, wchar_t* begin) {
            finish = start + boost::core::swprintf(
                begin, CharacterBufferSize, L"%.*Lg",
                static_cast<int>(boost::detail::lcast_precision<long double>::value),
                val.payload
            );
            return finish > start;
        }

    public:
        template <class C>
        using enable_if_compatible_char_t = typename std::enable_if<
            std::is_same<const C, const CharT>::value || (
                std::is_same<const char, const CharT>::value && (
                    std::is_same<const C, const unsigned char>::value ||
                    std::is_same<const C, const signed char>::value
                )
            ), bool
        >::type;

        template<class CharTraits, class Alloc>
        bool stream_in(lcast::exact<std::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
            start = x.payload.data();
            finish = start + x.payload.length();
            return true;
        }

        template<class CharTraits, class Alloc>
        bool stream_in(lcast::exact<boost::container::basic_string<CharT,CharTraits,Alloc>> x) noexcept {
            start = x.payload.data();
            finish = start + x.payload.length();
            return true;
        }

        bool stream_in(lcast::exact<bool> x) noexcept {
            CharT const czero = lcast_char_constants<CharT>::zero;
            Traits::assign(buffer[0], Traits::to_char_type(czero + x.payload));
            finish = start + 1;
            return true;
        }

        bool stream_in(lcast::exact<boost::conversion::detail::buffer_view<CharT>> x) noexcept {
            start = x.payload.begin;
            finish = x.payload.end;
            return true;
        }

        template <class C>
        enable_if_compatible_char_t<C>
        stream_in(lcast::exact<boost::iterator_range<C*>> x) noexcept {
            auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
            return stream_in(lcast::exact<decltype(buf)>{buf});
        }

        bool stream_in(lcast::exact<char> x) { return shl_char(x.payload); }
        bool stream_in(lcast::exact<unsigned char> x) { return shl_char(static_cast<char>(x.payload)); }
        bool stream_in(lcast::exact<signed char> x) { return shl_char(static_cast<char>(x.payload)); }


        template <class C>
        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
                stream_in(lcast::exact<C> x) { return shl_char(x.payload); }


        template <class Type>
        enable_if_compatible_char_t<Type>
                stream_in(lcast::exact<Type*> x) { return shl_char_array(reinterpret_cast<CharT const*>(x.payload)); }

        template <class Type>
        typename std::enable_if<!std::is_floating_point<Type>::value && boost::detail::lcast::is_signed<Type>::value && !std::is_enum<Type>::value, bool>::type
                stream_in(lcast::exact<Type> x) { return shl_signed(x.payload); }

        template <class Type>
        typename std::enable_if<boost::detail::lcast::is_unsigned<Type>::value && !std::is_enum<Type>::value, bool>::type
                stream_in(lcast::exact<Type> x) { return shl_unsigned(x.payload); }

        template <class Type>
        auto stream_in(lcast::exact<Type> x) -> decltype(shl_real_type(x, buffer)) {
            const CharT* inf_nan = detail::get_inf_nan(x.payload, CharT());
            if (inf_nan) {
                start = inf_nan;
                finish = start + Traits::length(inf_nan);
                return true;
            }
            return shl_real_type(x, buffer);
        }

        template <class C, std::size_t N>
        enable_if_compatible_char_t<C>
        stream_in(lcast::exact<boost::array<C, N>> x) noexcept {
            return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
        }

        template <class C, std::size_t N>
        enable_if_compatible_char_t<C>
        stream_in(lcast::exact<std::array<C, N>> x) noexcept {
            return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), N);
        }


        template <class C, class CharTraits>
        enable_if_compatible_char_t<C>
        stream_in(lcast::exact<std::basic_string_view<C, CharTraits>> x) noexcept {
            start = reinterpret_cast<const CharT*>(x.payload.data());
            finish = start + x.payload.size();
            return true;
        }

        template <class C, class CharTraits>
        enable_if_compatible_char_t<C>
        stream_in(lcast::exact<boost::basic_string_view<C, CharTraits>> x) noexcept {
            start = reinterpret_cast<const CharT*>(x.payload.data());
            finish = start + x.payload.size();
            return true;
        }
    };


    template <class CharT, class Traits>
    class ios_src_stream {
        typedef detail::lcast::out_stream_t<CharT, Traits> deduced_out_stream_t;
        typedef detail::lcast::stringbuffer_t<CharT, Traits> deduced_out_buffer_t;

        deduced_out_buffer_t out_buffer;
        deduced_out_stream_t out_stream;

        const CharT* start = nullptr;
        const CharT* finish = nullptr;
    public:
        ios_src_stream(ios_src_stream&&) = delete;
        ios_src_stream(const ios_src_stream&) = delete;
        ios_src_stream& operator=(ios_src_stream&&) = delete;
        ios_src_stream& operator=(const ios_src_stream&) = delete;

        ios_src_stream(): out_buffer(), out_stream(&out_buffer) {}

        const CharT* cbegin() const noexcept {
            return start;
        }

        const CharT* cend() const noexcept {
            return finish;
        }
    private:
        const deduced_out_buffer_t* get_rdbuf() const {
            return static_cast<deduced_out_buffer_t*>(
                out_stream.rdbuf()
            );
        }

        template<typename InputStreamable>
        bool shl_input_streamable(InputStreamable& input) {







            out_stream.exceptions(std::ios::badbit);
            try {

            bool const result = !(out_stream << input).fail();
            const auto* const p = get_rdbuf();
            start = p->pbase();
            finish = p->pptr();
            return result;

            } catch (const ::std::ios_base::failure& ) {
                return false;
            }

        }

        template <class T>
        bool shl_char_array(T const* str_value) {
            static_assert(sizeof(T) <= sizeof(CharT),
                "boost::lexical_cast does not support narrowing of char types."
                "Use boost::locale instead" );
            return shl_input_streamable(str_value);
        }

        template <class T>
        bool shl_real(T val) {
            const CharT* inf_nan = detail::get_inf_nan(val, CharT());
            if (inf_nan) {
                start = inf_nan;
                finish = start + Traits::length(inf_nan);
                return true;
            }

            boost::detail::lcast_set_precision(out_stream, &val);
            return shl_input_streamable(val);
        }

    public:
        template <class Type>
        typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) == sizeof(Type), bool>::type
                stream_in(lcast::exact<const Type*> x) { return shl_char_array(reinterpret_cast<char const*>(x.payload)); }

        template <class Type>
        typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) != sizeof(Type), bool>::type
                stream_in(lcast::exact<const Type*> x) { return shl_char_array(x.payload); }

        bool stream_in(lcast::exact<float> x) { return shl_real(x.payload); }
        bool stream_in(lcast::exact<double> x) { return shl_real(x.payload); }
        bool stream_in(lcast::exact<long double> x) {

            return shl_real(x.payload);



        }

        template <class C>
        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
        stream_in(lcast::exact<iterator_range<C*>> x) noexcept {
            auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
            return stream_in(lcast::exact<decltype(buf)>{buf});
        }

        template <class C>
        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
        stream_in(lcast::exact<iterator_range<const C*>> x) noexcept {
            auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
            return stream_in(lcast::exact<decltype(buf)>{buf});
        }

        template <class InStreamable>
        bool stream_in(lcast::exact<InStreamable> x) { return shl_input_streamable(x.payload); }
    };


    template <class CharT, class Traits>
    class to_target_stream {

        const CharT* start;
        const CharT* const finish;

    public:
        to_target_stream(to_target_stream&&) = delete;
        to_target_stream(const to_target_stream&) = delete;
        to_target_stream& operator=(to_target_stream&&) = delete;
        to_target_stream& operator=(const to_target_stream&) = delete;

        to_target_stream(const CharT* begin, const CharT* end) noexcept
          : start(begin)
          , finish(end)
        {}

    private:
        template <typename Type>

        __attribute__((no_sanitize("unsigned-integer-overflow")))

        bool shr_unsigned(Type& output) {
            if (start == finish) return false;
            CharT const minus = lcast_char_constants<CharT>::minus;
            CharT const plus = lcast_char_constants<CharT>::plus;
            bool const has_minus = Traits::eq(minus, *start);


            if (has_minus || Traits::eq(plus, *start)) {
                ++start;
            }

            bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();

            if (has_minus) {
                output = static_cast<Type>(0u - output);
            }

            return succeed;
        }

        template <typename Type>

        __attribute__((no_sanitize("unsigned-integer-overflow")))

        bool shr_signed(Type& output) {
            if (start == finish) return false;
            CharT const minus = lcast_char_constants<CharT>::minus;
            CharT const plus = lcast_char_constants<CharT>::plus;
            typedef typename boost::detail::lcast::make_unsigned<Type>::type utype;
            utype out_tmp = 0;
            bool const has_minus = Traits::eq(minus, *start);


            if (has_minus || Traits::eq(plus, *start)) {
                ++start;
            }

            bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
            if (has_minus) {
                utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
                succeed = succeed && out_tmp<=comp_val;
                output = static_cast<Type>(0u - out_tmp);
            } else {
                utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
                succeed = succeed && out_tmp<=comp_val;
                output = static_cast<Type>(out_tmp);
            }
            return succeed;
        }

        template<typename InputStreamable>
        bool shr_using_base_class(InputStreamable& output)
        {
            static_assert(
                !std::is_pointer<InputStreamable>::value,
                "boost::lexical_cast can not convert to pointers"
            );
# 562 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3
            typedef detail::lcast::buffer_t<CharT, Traits> buffer_t;
            buffer_t buf;


            buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));



            std::basic_istream<CharT, Traits> stream(&buf);




            stream.exceptions(std::ios::badbit);
            try {

            stream.unsetf(std::ios::skipws);
            boost::detail::lcast_set_precision(stream, static_cast<InputStreamable*>(0));

            return (stream >> output)
                && (stream.get() == Traits::eof());


            } catch (const ::std::ios_base::failure& ) {
                return false;
            }

        }

        template<class T>
        inline bool shr_xchar(T& output) noexcept {
            static_assert(sizeof(CharT) == sizeof(T),
                "boost::lexical_cast does not support narrowing of character types."
                "Use boost::locale instead" );
            bool const ok = (finish - start == 1);
            if (ok) {
                CharT out;
                Traits::assign(out, *start);
                output = static_cast<T>(out);
            }
            return ok;
        }

        template <std::size_t N, class ArrayT>
        bool shr_std_array(ArrayT& output) noexcept {
            const std::size_t size = static_cast<std::size_t>(finish - start);
            if (size > N - 1) {
                return false;
            }

            std::memcpy(&output[0], start, size * sizeof(CharT));
            output[size] = Traits::to_char_type(0);
            return true;
        }

    public:
        bool stream_out(unsigned short& output) { return shr_unsigned(output); }
        bool stream_out(unsigned int& output) { return shr_unsigned(output); }
        bool stream_out(unsigned long int& output) { return shr_unsigned(output); }
        bool stream_out(short& output) { return shr_signed(output); }
        bool stream_out(int& output) { return shr_signed(output); }
        bool stream_out(long int& output) { return shr_signed(output); }

        bool stream_out(boost::ulong_long_type& output) { return shr_unsigned(output); }
        bool stream_out(boost::long_long_type& output) { return shr_signed(output); }






        bool stream_out(boost::uint128_type& output) { return shr_unsigned(output); }
        bool stream_out(boost::int128_type& output) { return shr_signed(output); }


        bool stream_out(char& output) { return shr_xchar(output); }
        bool stream_out(unsigned char& output) { return shr_xchar(output); }
        bool stream_out(signed char& output) { return shr_xchar(output); }

        bool stream_out(wchar_t& output) { return shr_xchar(output); }


        bool stream_out(char16_t& output) { return shr_xchar(output); }


        bool stream_out(char32_t& output) { return shr_xchar(output); }

        template<class CharTraits, class Alloc>
        bool stream_out(std::basic_string<CharT,CharTraits,Alloc>& str) {
            str.assign(start, finish); return true;
        }

        template<class CharTraits, class Alloc>
        bool stream_out(boost::container::basic_string<CharT,CharTraits,Alloc>& str) {
            str.assign(start, finish); return true;
        }

        template <class C, std::size_t N>
        bool stream_out(std::array<C, N>& output) noexcept {
            static_assert(sizeof(C) == sizeof(CharT), "");
            return shr_std_array<N>(output);
        }

        template <class C, std::size_t N>
        bool stream_out(boost::array<C, N>& output) noexcept {
            static_assert(sizeof(C) == sizeof(CharT), "");
            return shr_std_array<N>(output);
        }

        bool stream_out(bool& output) noexcept {
            output = false;

            if (start == finish) return false;
            CharT const zero = lcast_char_constants<CharT>::zero;
            CharT const plus = lcast_char_constants<CharT>::plus;
            CharT const minus = lcast_char_constants<CharT>::minus;

            const CharT* const dec_finish = finish - 1;
            output = Traits::eq(*dec_finish, zero + 1);
            if (!output && !Traits::eq(*dec_finish, zero)) {
                return false;
            }

            if (start == dec_finish) return true;


            if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
                ++ start;
            }


            while (start != dec_finish) {
                if (!Traits::eq(zero, *start)) {
                    return false;
                }

                ++ start;
            }

            return true;
        }

    private:

        template <class T>
        bool float_types_converter_internal(T& output) {
            if (parse_inf_nan(start, finish, output)) return true;
            bool const return_value = shr_using_base_class(output);







            CharT const minus = lcast_char_constants<CharT>::minus;
            CharT const plus = lcast_char_constants<CharT>::plus;
            CharT const capital_e = lcast_char_constants<CharT>::capital_e;
            CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
            if ( return_value &&
                 (
                    Traits::eq(*(finish-1), lowercase_e)
                    || Traits::eq(*(finish-1), capital_e)
                    || Traits::eq(*(finish-1), minus)
                    || Traits::eq(*(finish-1), plus)
                 )
            ) return false;

            return return_value;
        }

    public:
        bool stream_out(float& output) { return float_types_converter_internal(output); }
        bool stream_out(double& output) { return float_types_converter_internal(output); }
        bool stream_out(long double& output) { return float_types_converter_internal(output); }



        template <typename InputStreamable>
        bool stream_out(InputStreamable& output) {
            return shr_using_base_class(output);
        }
    };

}}}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3

namespace boost {


    template<class T, std::size_t N>
    class array;
    template<class IteratorT>
    class iterator_range;


    template<class Ch, class Tr> class basic_string_view;

    namespace detail
    {

        template < class Char >
        struct normalize_single_byte_char
        {
            using type = Char;
        };

        template <>
        struct normalize_single_byte_char< signed char >
        {
            using type = char;
        };

        template <>
        struct normalize_single_byte_char< unsigned char >
        {
            using type = char;
        };
    }

    namespace detail
    {


        template < class T > struct deduce_character_type_later {};
    }

    namespace detail
    {



        template < typename Type >
        struct stream_char_common: public std::conditional<
            boost::detail::is_character< Type >::value,
            Type,
            boost::detail::deduce_character_type_later< Type >
        > {};

        template < typename Char >
        struct stream_char_common< Char* >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< Char* >
        > {};

        template < typename Char >
        struct stream_char_common< const Char* >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< const Char* >
        > {};

        template < typename Char >
        struct stream_char_common< boost::conversion::detail::buffer_view< Char > >
        {
            using type = Char;
        };

        template < typename Char >
        struct stream_char_common< boost::iterator_range< Char* > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
        > {};

        template < typename Char >
        struct stream_char_common< boost::iterator_range< const Char* > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
        > {};

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
        {
            using type = Char;
        };

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
        {
            using type = Char;
        };

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< Char, N > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< Char, N > >
        > {};

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< const Char, N > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< const Char, N > >
        > {};


        template < typename Char, std::size_t N >
        struct stream_char_common< std::array<Char, N > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< std::array< Char, N > >
        > {};

        template < typename Char, std::size_t N >
        struct stream_char_common< std::array< const Char, N > >: public std::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< std::array< const Char, N > >
        > {};



        template < class Char, class Traits >
        struct stream_char_common< std::basic_string_view< Char, Traits > >
        {
            using type = Char;
        };

        template < class Char, class Traits >
        struct stream_char_common< boost::basic_string_view< Char, Traits > >
        {
            using type = Char;
        };


        template <> struct stream_char_common< boost::int128_type >
        {
            using type = char;
        };
        template <> struct stream_char_common< boost::uint128_type >
        {
            using type = char;
        };
# 210 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
    }

    namespace detail
    {





        template < class Char >
        struct deduce_source_char_impl
        {
            typedef typename boost::detail::normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_source_char_impl< deduce_character_type_later< T > >
        {
            template <class U>
            static auto left_shift_type(long)
                -> decltype( std::declval<std::basic_ostream< char >&>() << std::declval<const U&>(), char{});


            template <class U>
            static auto left_shift_type(int)
                -> decltype( std::declval<std::basic_ostream< wchar_t >&>() << std::declval<const U&>(), wchar_t{});


            template <class U>
            static void left_shift_type(...);

            using type = decltype(left_shift_type<T>(1L));

            static_assert(!std::is_same<type, void>::value,




                "Source type is neither std::ostream`able nor std::wostream`able"

            );
        };
    }

    namespace detail
    {





        template < class Char >
        struct deduce_target_char_impl
        {
            typedef typename normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_target_char_impl< deduce_character_type_later<T> >
        {
            template <class U>
            static auto right_shift_type(long)
                -> decltype( std::declval<std::basic_istream< char >&>() >> std::declval<U&>(), char{});


            template <class U>
            static auto right_shift_type(int)
                -> decltype( std::declval<std::basic_istream< wchar_t >&>() >> std::declval<U&>(), wchar_t{});


            template <class U>
            static void right_shift_type(...);

            using type = decltype(right_shift_type<T>(1L));

            static_assert(!std::is_same<type, void>::value,




               "Target type is neither std::istream`able nor std::wistream`able"

            );
        };
    }

    namespace detail
    {
# 313 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
        template < class T >
        struct deduce_target_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_target_char_impl< stage1_type >::type type;
        };

        template < class T >
        struct deduce_source_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_source_char_impl< stage1_type >::type type;
        };
    }

    namespace detail
    {
        template<class T>
        struct array_to_pointer_decay
        {
            typedef T type;
        };

        template<class T, std::size_t N>
        struct array_to_pointer_decay<T[N]>
        {
            typedef const T * type;
        };
    }

    namespace detail
    {

        template< class Source,
                  class Enable = void
                >
        struct lcast_src_length
        {
            static const std::size_t value = 1;
        };
# 367 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
        template <class Source>
        struct lcast_src_length<
                    Source, typename std::enable_if<boost::detail::lcast::is_integral<Source>::value >::type
                >
        {
            static const std::size_t value = std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_specialized + std::numeric_limits<Source>::digits10 * 2;




        };
# 389 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
        template<class Source>
        struct lcast_src_length<
                Source, typename std::enable_if<std::is_floating_point<Source>::value >::type
            >
        {
            static_assert(
                    std::numeric_limits<Source>::max_exponent10 <= 999999L &&
                    std::numeric_limits<Source>::min_exponent10 >= -999999L
                , "");

            static const std::size_t value = 5 + lcast_precision<Source>::value + 6;


        };
    }

    namespace detail
    {
        template <class Source, class Target>
        struct lexical_cast_stream_traits {
            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
            typedef typename std::remove_cv<src>::type no_cv_src;

            typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
            typedef typename deduce_src_char_metafunc::type src_char_t;
            typedef typename boost::detail::deduce_target_char<Target>::type target_char_t;

            typedef typename boost::detail::widest_char<
                target_char_t, src_char_t
            >::type char_type;
# 431 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/detail/converter_lexical.hpp" 3
            typedef std::char_traits<char_type> traits;

            typedef boost::detail::lcast_src_length<no_cv_src> len_t;
        };
    }

    namespace detail
    {
        template<typename Target, typename Source>
        struct lexical_converter_impl
        {
            typedef lexical_cast_stream_traits<Source, Target> stream_trait;

            typedef detail::lcast::optimized_src_stream<
                typename stream_trait::char_type,
                typename stream_trait::traits,
                stream_trait::len_t::value + 1
            > optimized_src_stream;

            template <class T>
            static auto detect_type(int)
                -> decltype(std::declval<optimized_src_stream&>().stream_in(std::declval<lcast::exact<T>>()), optimized_src_stream{});

            template <class T>
            static lcast::ios_src_stream<typename stream_trait::char_type, typename stream_trait::traits> detect_type(...);

            using from_src_stream = decltype(detect_type<Source>(1));

            typedef detail::lcast::to_target_stream<
                typename stream_trait::char_type,
                typename stream_trait::traits
            > to_target_stream;

            static inline bool try_convert(const Source& arg, Target& result) {
                from_src_stream src_stream;
                if (!src_stream.stream_in(lcast::exact<Source>{arg}))
                    return false;

                to_target_stream out(src_stream.cbegin(), src_stream.cend());
                if (!out.stream_out(result))
                    return false;

                return true;
            }
        };
    }

}
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3

namespace boost {
    namespace detail
    {
        template<typename Target, typename Source>
        using is_arithmetic_and_not_xchars = std::integral_constant<
            bool,
            !(boost::detail::is_character<Target>::value) &&
                !(boost::detail::is_character<Source>::value) &&
                std::is_arithmetic<Source>::value &&
                std::is_arithmetic<Target>::value
        >;
    }

    namespace conversion { namespace detail {

        template <typename Target, typename Source>
        inline bool try_lexical_convert(const Source& arg, Target& result)
        {
            static_assert(
                !std::is_volatile<Source>::value,
                "Boost.LexicalCast does not support volatile input");

            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;

            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
                shall_we_copy_with_dynamic_check_t;

            typedef typename std::conditional<
                 shall_we_copy_with_dynamic_check_t::value,
                 boost::detail::dynamic_num_converter_impl<Target, src >,
                 boost::detail::lexical_converter_impl<Target, src >
            >::type caster_type;

            return caster_type::try_convert(arg, result);
        }

        template <typename Target, typename CharacterT>
        inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
        {
            static_assert(
                boost::detail::is_character<CharacterT>::value,
                "This overload of try_lexical_convert is meant to be used only with arrays of characters."
            );
            return ::boost::conversion::detail::try_lexical_convert(
                ::boost::conversion::detail::make_buffer_view(chars, chars + count),
                result
            );
        }

    }}

    namespace conversion {

        using ::boost::conversion::detail::try_lexical_convert;
    }

}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/boost/lexical_cast.hpp" 2 3

namespace boost
{
    template <typename Target, typename Source>
    inline Target lexical_cast(const Source &arg)
    {
        Target result = Target();

        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
            boost::conversion::detail::throw_bad_cast<Source, Target>();
        }

        return result;
    }

    template <typename Target>
    inline Target lexical_cast(const char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }

    template <typename Target>
    inline Target lexical_cast(const unsigned char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }

    template <typename Target>
    inline Target lexical_cast(const signed char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }


    template <typename Target>
    inline Target lexical_cast(const wchar_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }

    template <typename Target>
    inline Target lexical_cast(const char16_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }
    template <typename Target>
    inline Target lexical_cast(const char32_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
        );
    }

}
# 19 "include/framework/logging/LogVariableStream.h" 2





class LogVar {
public:






  template<class TVarType>
  LogVar(const std::string& name, const TVarType& v) : m_name(name)
  {
    if constexpr(std::is_enum_v<TVarType>) {


      auto underlying_value = static_cast<typename std::underlying_type_t<TVarType>>(v);
      m_value = std::to_string(underlying_value);
    } else {
      m_value = boost::lexical_cast<std::string>(v);
    }
  }




  std::string getValue() const
  {
    return m_value;
  }




  std::string getName() const
  {
    return m_name;
  }




  bool operator==(const LogVar& lv) const
  {
    return (lv.m_name == this->m_name) && (lv.m_value == this->m_value);
  }

private:


  std::string m_name;



  std::string m_value;
};




class LogModRealm {
public:





  LogModRealm(Belle2::LogConfig::ELogRealm realm, Belle2::LogConfig::ELogLevel logLevel) :
    m_realm(realm),
    m_logLevel(logLevel)
  {
  }




  Belle2::LogConfig::ELogRealm getRealm() const
  {
    return m_realm;
  }




  Belle2::LogConfig::ELogLevel getLogLevel() const
  {
    return m_logLevel;
  }

private:

  Belle2::LogConfig::ELogRealm m_realm;


  Belle2::LogConfig::ELogLevel m_logLevel;
};
# 133 "include/framework/logging/LogVariableStream.h"
class LogVariableStream {
public:


  typedef std::basic_ostream<std::stringstream::char_type, std::stringstream::traits_type > __basic_ostream_type;


  LogVariableStream() = default;




  LogVariableStream(LogVariableStream&&) = default;




  LogVariableStream(const LogVariableStream& other) : m_variables(other.m_variables), m_logLevelOverride(other.m_logLevelOverride)
  {

    m_stringStream << other.m_stringStream.str();
  }





  explicit LogVariableStream(std::string const& text, std::map<std::string, std::string> variables = {})
  {
    m_stringStream << text;
    for (auto const& kv : variables) {
      m_variables.emplace_back(LogVar(kv.first, kv.second));
    }
  }






  LogVariableStream& operator<<(__basic_ostream_type & (*__pf)(__basic_ostream_type&))
  {

    __pf(m_stringStream);
    return *this;
  }





  LogVariableStream& operator<<(LogVar const& var)
  {
    m_variables.push_back(var);
    return *this;
  }




  LogVariableStream& operator<<(LogModRealm const& var);





  template<class TText>
  typename std::enable_if<not std::is_fundamental<TText>::value, LogVariableStream&>::type operator<<(TText const& text)
  {
    this->m_stringStream << text;
    return *this;
  }






  template<class PODTYPE>
  typename std::enable_if<std::is_fundamental<PODTYPE>::value, LogVariableStream&>::type operator<<(PODTYPE pod)
  {
    this->m_stringStream << pod;
    return *this;
  }




  bool operator==(const LogVariableStream& lvs) const
  {
    return (lvs.m_variables == this->m_variables) && (lvs.m_stringStream.str() == this->m_stringStream.str());
  }




  LogVariableStream& operator=(const LogVariableStream& lvs)
  {
    this->m_stringStream = std::stringstream();
    this->m_stringStream << lvs.m_stringStream.str();
    this->m_variables = lvs.m_variables;
    this->m_logLevelOverride = lvs.m_logLevelOverride;
    return *this;
  }





  std::string str(bool showVariables = true) const
  {


    if (m_variables.size() == 0 or !showVariables) {
      return m_stringStream.str();
    }

    std::stringstream tmpBuffer;

    tmpBuffer << m_stringStream.str();
    for (auto const& v : m_variables) {
      tmpBuffer << std::endl << "\t" << v.getName() << " = " << v.getValue();
    }
    return tmpBuffer.str();
  }


  std::string getMessage() const
  {
    return m_stringStream.str();
  }


  const std::vector<LogVar>& getVariables() const
  {
    return m_variables;
  }


  void adjustLogLevel(Belle2::LogConfig::ELogLevel& logLevel) const
  {
    if (m_logLevelOverride != Belle2::LogConfig::c_Default) {
      logLevel = m_logLevelOverride;
    }
  }

private:


  std::stringstream m_stringStream;


  std::vector<LogVar> m_variables;


  Belle2::LogConfig::ELogLevel m_logLevelOverride = Belle2::LogConfig::c_Default;
};
# 13 "include/framework/logging/LogMessage.h" 2





namespace Belle2 {






  class LogMessage {
  public:
# 40 "include/framework/logging/LogMessage.h"
    LogMessage(LogConfig::ELogLevel logLevel, const std::string& message, const char* package,
               std::string function, std::string file, unsigned int line, int debugLevel = 0);
# 54 "include/framework/logging/LogMessage.h"
    LogMessage(LogConfig::ELogLevel logLevel, LogVariableStream&& messageStream, const char* package,
               std::string function, std::string file, unsigned int line, int debugLevel = 0);




    LogMessage(LogMessage&&) = default;




    LogMessage(LogMessage const& lm) = default;






    bool operator==(const LogMessage& message) const;


    bool operator!=(const LogMessage& message) const { return !(*this == message); }




    LogMessage& operator=(const LogMessage& lvs) = default;






    LogConfig::ELogLevel getLogLevel() const {return m_logLevel; }






    const std::string& getPackage() const {return m_package; }






    const std::string getMessage() const { return m_message.str(); }




    void setModule(const std::string& module) {m_module = module; }




    void setLogInfo(unsigned int logInfo) {m_logInfo = logInfo; }




    void setCount(int count) {m_count = count; }






    std::ostream& print(std::ostream& out) const;





    std::string toJSON(bool complete) const;


    const std::vector<LogVar>& getLogVariables() const { return m_message.getVariables(); }






    struct TextHasher {

      std::size_t operator()(const LogMessage& msg) const
      {
        return msg.m_logLevel ^ std::hash<std::string>()(msg.m_message.getMessage());
      }

      bool operator()(const LogMessage& lhs, const LogMessage& rhs) const
      {
        return (lhs.m_logLevel == rhs.m_logLevel) &&
               (lhs.m_message.getMessage() == rhs.m_message.getMessage());
      }
    };
  private:

    LogConfig::ELogLevel m_logLevel;
    LogVariableStream m_message;
    std::string m_module;
    std::string m_package;
    std::string m_function;
    std::string m_file;
    unsigned int m_line;
    int m_debugLevel;

    unsigned int m_logInfo;
    int m_count;
  };
}




extern std::ostream& operator<< (std::ostream& out, const Belle2::LogMessage& logMessage);
# 13 "include/framework/logging/Logger.h" 2
# 1 "include/framework/logging/LogSystem.h" 1
# 20 "include/framework/logging/LogSystem.h"
namespace Belle2 {
  class LogConnectionBase;
# 42 "include/framework/logging/LogSystem.h"
  class LogSystem {
  public:
    static const unsigned int c_errorSummaryMaxLines = 10000;






    static LogSystem& Instance();
# 61 "include/framework/logging/LogSystem.h"
    void addLogConnection(LogConnectionBase* logConnection);




    void resetLogConnections();


    void resetLogging();




    LogConfig* getLogConfig() {return &m_logConfig;}
# 83 "include/framework/logging/LogSystem.h"
    void addPackageLogConfig(const std::string& package, const LogConfig& logConfig) { m_packageLogConfigs[package] = logConfig; }
# 92 "include/framework/logging/LogSystem.h"
    LogConfig& getPackageLogConfig(const std::string& package) { return m_packageLogConfigs[package]; }
# 101 "include/framework/logging/LogSystem.h"
    LogConfig& getModuleLogConfig(const std::string& module) { return m_moduleLogConfigs[module]; }
# 110 "include/framework/logging/LogSystem.h"
    bool isLevelEnabled(LogConfig::ELogLevel level, int debugLevel = 0, const char* package = nullptr) const;
# 121 "include/framework/logging/LogSystem.h"
    bool sendMessage(LogMessage&& message);


    void resetMessageCounter();







    int getMessageCounter(LogConfig::ELogLevel logLevel) const;
# 144 "include/framework/logging/LogSystem.h"
    const LogConfig& getCurrentLogConfig(const char* package = nullptr) const;






    LogConfig::ELogLevel getCurrentLogLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getLogLevel(); }






    int getCurrentDebugLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getDebugLevel(); }






    unsigned getMaxMessageRepetitions() const { return m_maxErrorRepetition; }






    void setMaxMessageRepetitions(unsigned repetitions) { m_maxErrorRepetition = repetitions; }






    void printErrorSummary();






    void enableErrorSummary(bool on) { m_printErrorSummary = on; }
# 196 "include/framework/logging/LogSystem.h"
    void updateModule(const LogConfig* moduleLogConfig = nullptr, const std::string& moduleName = "") { m_moduleLogConfig = moduleLogConfig; m_moduleName = moduleName; }




    static void enableDebug() {s_debugEnabled = true;}




    inline static bool debugEnabled() {return s_debugEnabled;}

  private:

    std::vector<LogConnectionBase*> m_logConnections;

    LogConfig m_logConfig;

    const LogConfig* m_moduleLogConfig;

    std::string m_moduleName;

    std::map<std::string, LogConfig> m_packageLogConfigs;

    std::map<std::string, LogConfig> m_moduleLogConfigs;

    bool m_printErrorSummary;

    std::unordered_map<LogMessage, int, LogMessage::TextHasher, LogMessage::TextHasher> m_messageLog{100};

    unsigned int m_maxErrorRepetition{0};

    unsigned int m_suppressedMessages{0};

    int m_messageCounter[LogConfig::c_Default];

    static bool s_debugEnabled;


    LogSystem();


    LogSystem(const LogSystem&) = delete;


    LogSystem& operator=(const LogSystem&) = delete;


    ~LogSystem();






    void incMessageCounter(LogConfig::ELogLevel logLevel);


    bool deliverMessageToConnections(const LogMessage& msg);







    void showText(LogConfig::ELogLevel level, const std::string& txt, int info = LogConfig::c_Message);
  };

  inline const LogConfig& LogSystem::getCurrentLogConfig(const char* package) const
  {

    if (m_moduleLogConfig && (m_moduleLogConfig->getLogLevel() != LogConfig::c_Default)) {
      return *m_moduleLogConfig;
    }

    if (package && !m_packageLogConfigs.empty()) {

      if (auto it = m_packageLogConfigs.find(package); it != m_packageLogConfigs.end()) {
        const LogConfig& logConfig = it->second;
        if (logConfig.getLogLevel() != LogConfig::c_Default)
          return logConfig;
      }
    }

    return m_logConfig;
  }

  inline bool LogSystem::isLevelEnabled(LogConfig::ELogLevel level, int debugLevel, const char* package) const
  {
    const LogConfig& config = getCurrentLogConfig(package);
    const LogConfig::ELogLevel logLevelLimit = config.getLogLevel();
    const int debugLevelLimit = config.getDebugLevel();
    return logLevelLimit <= level && (level != LogConfig::c_Debug || debugLevelLimit >= debugLevel);
  }

}
# 14 "include/framework/logging/Logger.h" 2
# 20 "klm/bklm/geometry/src/GeometryPar.cc" 2
# 1 "include/framework/database/DBObjPtr.h" 1
# 10 "include/framework/database/DBObjPtr.h"
# 1 "include/framework/database/DBAccessorBase.h" 1
# 10 "include/framework/database/DBAccessorBase.h"
# 1 "include/framework/database/DBStore.h" 1
# 10 "include/framework/database/DBStore.h"
# 1 "include/framework/database/DBStoreEntry.h" 1
# 10 "include/framework/database/DBStoreEntry.h"
# 1 "include/framework/database/IntervalOfValidity.h" 1
# 14 "include/framework/database/IntervalOfValidity.h"
namespace Belle2 {
  class EventMetaData;





  class IntervalOfValidity final {
  public:

    IntervalOfValidity(): IntervalOfValidity(-1, -1, -1, -1) {}
# 33 "include/framework/database/IntervalOfValidity.h"
    IntervalOfValidity(int experimentLow, int runLow, int experimentHigh, int runHigh);




    ~IntervalOfValidity() = default;







    bool contains(const int experiment, const int run) const;






    bool contains(const EventMetaData& event) const;





    bool empty() const {return ((m_experimentLow < 0) && (m_experimentHigh < 0));};






    static IntervalOfValidity always() {return IntervalOfValidity(0, 0, -1, -1);};




    bool operator==(const IntervalOfValidity& other) const
    {
      return (m_experimentLow == other.m_experimentLow) && (m_runLow == other.m_runLow) &&
             (m_experimentHigh == other.m_experimentHigh) && (m_runHigh == other.m_runHigh);
    }




    bool operator!=(const IntervalOfValidity& other) const
    {
      return !(*this == other);
    }






    bool contains(const IntervalOfValidity& iov) const {return overlap(iov) == iov;};






    bool overlaps(const IntervalOfValidity& iov) const {return !overlap(iov).empty();};






    IntervalOfValidity overlap(const IntervalOfValidity& iov) const;







    bool trimOverlap(IntervalOfValidity& iov, bool trimOlder = true);
# 121 "include/framework/database/IntervalOfValidity.h"
    int getExperimentLow() const
    {
      return m_experimentLow;
    }




    int getRunLow() const
    {
      return m_runLow;
    }
# 141 "include/framework/database/IntervalOfValidity.h"
    int getExperimentHigh() const
    {
      return m_experimentHigh;
    }




    int getRunHigh() const
    {
      return m_runHigh;
    }






    friend std::istream& operator>> (std::istream& input, IntervalOfValidity& iov);






    friend std::ostream& operator<< (std::ostream& output, const IntervalOfValidity& iov);

  private:



    int m_experimentLow;



    int m_runLow;



    int m_experimentHigh;



    int m_runHigh;
# 194 "include/framework/database/IntervalOfValidity.h"
    int checkLowerBound(int experiment, int run) const;
# 204 "include/framework/database/IntervalOfValidity.h"
    int checkUpperBound(int experiment, int run) const;




    void makeValid();

    private: static_assert(std::is_integral<decltype(2)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("IntervalOfValidity") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 2; } TClass *IsA() const { return IntervalOfValidity::Class(); } void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(IntervalOfValidity::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { IntervalOfValidity::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/database/IntervalOfValidity.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) ; static int DeclFileLine() { return 211; };
  };
}
# 11 "include/framework/database/DBStoreEntry.h" 2
# 1 "include/framework/database/IntraRunDependency.h" 1
# 11 "include/framework/database/IntraRunDependency.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSeqCollection.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSeqCollection.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIterator.h" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIterator.h" 3
class TCollection;
class TObject;

class TIterator {

protected:
   TIterator() { }
   TIterator(const TIterator &) { }

public:
   virtual TIterator &operator=(const TIterator &) = 0;
   virtual ~TIterator() { }
   virtual const TCollection *GetCollection() const = 0;
   virtual Option_t *GetOption() const { return ""; }
   virtual TObject *Next() = 0;
   virtual void Reset() = 0;
   TObject *operator()() { return Next(); }
   virtual Bool_t operator!=(const TIterator &) const;
   Bool_t operator==(const TIterator & other) const { return !(*this != other); }
   virtual TObject *operator*() const;

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TIterator") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } virtual TClass *IsA() const { return TIterator::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TIterator::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TIterator::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TIterator.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 48; }
};
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TMathBase.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TMathBase.h" 3
namespace TMath {


   inline Short_t Abs(Short_t d);
   inline Int_t Abs(Int_t d);
   inline Long_t Abs(Long_t d);
   inline Long64_t Abs(Long64_t d);
   inline Float_t Abs(Float_t d);
   inline Double_t Abs(Double_t d);
   inline LongDouble_t Abs(LongDouble_t d);


   inline Bool_t Even(Long_t a);
   inline Bool_t Odd(Long_t a);


   template<typename Integer>
   inline Bool_t SignBit(Integer a);
   inline Bool_t SignBit(Float_t a);
   inline Bool_t SignBit(Double_t a);
   inline Bool_t SignBit(LongDouble_t a);


   template<typename T1, typename T2>
   inline T1 Sign( T1 a, T2 b);
   inline Float_t Sign(Float_t a, Float_t b);
   inline Double_t Sign(Double_t a, Double_t b);
   inline LongDouble_t Sign(LongDouble_t a, LongDouble_t b);


   inline Short_t Min(Short_t a, Short_t b);
   inline UShort_t Min(UShort_t a, UShort_t b);
   inline Int_t Min(Int_t a, Int_t b);
   inline UInt_t Min(UInt_t a, UInt_t b);
   inline Long_t Min(Long_t a, Long_t b);
   inline ULong_t Min(ULong_t a, ULong_t b);
   inline Long64_t Min(Long64_t a, Long64_t b);
   inline ULong64_t Min(ULong64_t a, ULong64_t b);
   inline Float_t Min(Float_t a, Float_t b);
   inline Double_t Min(Double_t a, Double_t b);

   inline Short_t Max(Short_t a, Short_t b);
   inline UShort_t Max(UShort_t a, UShort_t b);
   inline Int_t Max(Int_t a, Int_t b);
   inline UInt_t Max(UInt_t a, UInt_t b);
   inline Long_t Max(Long_t a, Long_t b);
   inline ULong_t Max(ULong_t a, ULong_t b);
   inline Long64_t Max(Long64_t a, Long64_t b);
   inline ULong64_t Max(ULong64_t a, ULong64_t b);
   inline Float_t Max(Float_t a, Float_t b);
   inline Double_t Max(Double_t a, Double_t b);


   inline Short_t Range(Short_t lb, Short_t ub, Short_t x);
   inline Int_t Range(Int_t lb, Int_t ub, Int_t x);
   inline Long_t Range(Long_t lb, Long_t ub, Long_t x);
   inline ULong_t Range(ULong_t lb, ULong_t ub, ULong_t x);
   inline Double_t Range(Double_t lb, Double_t ub, Double_t x);


   Long_t NextPrime(Long_t x);


   template <typename T> Long64_t BinarySearch(Long64_t n, const T *array, T value);
   template <typename T> Long64_t BinarySearch(Long64_t n, const T **array, T value);
   template <typename Iterator, typename Element> Iterator BinarySearch(Iterator first, Iterator last, Element value);


   template <typename Element, typename Index>
   void Sort(Index n, const Element* a, Index* index, Bool_t down=kTRUE);
   template <typename Iterator, typename IndexIterator>
   void SortItr(Iterator first, Iterator last, IndexIterator index, Bool_t down=kTRUE);
}





inline Bool_t TMath::Even(Long_t a)
   { return ! (a & 1); }


inline Bool_t TMath::Odd(Long_t a)
   { return (a & 1); }




inline Short_t TMath::Abs(Short_t d)
{ return (d >= 0) ? d : Short_t(-d); }


inline Int_t TMath::Abs(Int_t d)
{ return std::abs(d); }


inline Long_t TMath::Abs(Long_t d)
{ return std::labs(d); }


inline Long64_t TMath::Abs(Long64_t d)
{ return std::llabs(d); }


inline Float_t TMath::Abs(Float_t d)
{ return std::abs(d); }


inline Double_t TMath::Abs(Double_t d)
{ return std::abs(d); }


inline LongDouble_t TMath::Abs(LongDouble_t d)
{ return std::abs(d); }





template<typename Integer>
inline Bool_t TMath::SignBit( Integer a)
   { return (a < 0); }


inline Bool_t TMath::SignBit(Float_t a)
   { return std::signbit(a); }


inline Bool_t TMath::SignBit(Double_t a)
   { return std::signbit(a); }


inline Bool_t TMath::SignBit(LongDouble_t a)
   { return std::signbit(a); }





template<typename T1, typename T2>
inline T1 TMath::Sign( T1 a, T2 b)
   { return (SignBit(b)) ? - Abs(a) : Abs(a); }



inline Float_t TMath::Sign(Float_t a, Float_t b)
   { return std::copysign(a,b); }



inline Double_t TMath::Sign(Double_t a, Double_t b)
   { return std::copysign(a,b); }



inline LongDouble_t TMath::Sign(LongDouble_t a, LongDouble_t b)
   { return std::copysign(a,b); }






inline Short_t TMath::Min(Short_t a, Short_t b)
   { return a <= b ? a : b; }



inline UShort_t TMath::Min(UShort_t a, UShort_t b)
   { return a <= b ? a : b; }



inline Int_t TMath::Min(Int_t a, Int_t b)
   { return a <= b ? a : b; }



inline UInt_t TMath::Min(UInt_t a, UInt_t b)
   { return a <= b ? a : b; }



inline Long_t TMath::Min(Long_t a, Long_t b)
   { return a <= b ? a : b; }



inline ULong_t TMath::Min(ULong_t a, ULong_t b)
   { return a <= b ? a : b; }



inline Long64_t TMath::Min(Long64_t a, Long64_t b)
   { return a <= b ? a : b; }



inline ULong64_t TMath::Min(ULong64_t a, ULong64_t b)
   { return a <= b ? a : b; }



inline Float_t TMath::Min(Float_t a, Float_t b)
   { return a <= b ? a : b; }



inline Double_t TMath::Min(Double_t a, Double_t b)
   { return a <= b ? a : b; }





inline Short_t TMath::Max(Short_t a, Short_t b)
   { return a >= b ? a : b; }



inline UShort_t TMath::Max(UShort_t a, UShort_t b)
   { return a >= b ? a : b; }



inline Int_t TMath::Max(Int_t a, Int_t b)
   { return a >= b ? a : b; }



inline UInt_t TMath::Max(UInt_t a, UInt_t b)
   { return a >= b ? a : b; }



inline Long_t TMath::Max(Long_t a, Long_t b)
   { return a >= b ? a : b; }



inline ULong_t TMath::Max(ULong_t a, ULong_t b)
   { return a >= b ? a : b; }



inline Long64_t TMath::Max(Long64_t a, Long64_t b)
   { return a >= b ? a : b; }



inline ULong64_t TMath::Max(ULong64_t a, ULong64_t b)
   { return a >= b ? a : b; }



inline Float_t TMath::Max(Float_t a, Float_t b)
   { return a >= b ? a : b; }



inline Double_t TMath::Max(Double_t a, Double_t b)
   { return a >= b ? a : b; }





inline Short_t TMath::Range(Short_t lb, Short_t ub, Short_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }



inline Int_t TMath::Range(Int_t lb, Int_t ub, Int_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }



inline Long_t TMath::Range(Long_t lb, Long_t ub, Long_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }



inline ULong_t TMath::Range(ULong_t lb, ULong_t ub, ULong_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }



inline Double_t TMath::Range(Double_t lb, Double_t ub, Double_t x)
   { return x < lb ? lb : (x > ub ? ub : x); }







template <typename Iterator, typename Element>
Iterator TMath::BinarySearch(Iterator first, Iterator last, Element value)
{
   Iterator pind;
   pind = std::lower_bound(first, last, value);
   if ( (pind != last) && (*pind == value) )
      return pind;
   else
      return ( pind - 1);
}






template <typename T> Long64_t TMath::BinarySearch(Long64_t n, const T *array, T value)
{
   const T* pind;
   pind = std::lower_bound(array, array + n, value);
   if ( (pind != array + n) && (*pind == value) )
      return (pind - array);
   else
      return ( pind - array - 1);
}






template <typename T> Long64_t TMath::BinarySearch(Long64_t n, const T **array, T value)
{
   const T* pind;
   pind = std::lower_bound(*array, *array + n, value);
   if ( (pind != *array + n) && (*pind == value) )
      return (pind - *array);
   else
      return ( pind - *array - 1);
}

template<typename T>
struct CompareDesc {

   CompareDesc(T d) : fData(d) {}

   template<typename Index>
   bool operator()(Index i1, Index i2) {
      return *(fData + i1) > *(fData + i2);
   }

   T fData;
};

template<typename T>
struct CompareAsc {

   CompareAsc(T d) : fData(d) {}

   template<typename Index>
   bool operator()(Index i1, Index i2) {
      return *(fData + i1) < *(fData + i2);
   }

   T fData;
};
# 405 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TMathBase.h" 3
template <typename Iterator, typename IndexIterator>
void TMath::SortItr(Iterator first, Iterator last, IndexIterator index, Bool_t down)
{
   int i = 0;

   IndexIterator cindex = index;
   for ( Iterator cfirst = first; cfirst != last; ++cfirst )
   {
      *cindex = i++;
      ++cindex;
   }

   if ( down )
      std::sort(index, cindex, CompareDesc<Iterator>(first) );
   else
      std::sort(index, cindex, CompareAsc<Iterator>(first) );
}
# 431 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TMathBase.h" 3
template <typename Element, typename Index> void TMath::Sort(Index n, const Element* a, Index* index, Bool_t down)
{
   for(Index i = 0; i < n; i++) { index[i] = i; }
   if ( down )
      std::sort(index, index + n, CompareDesc<const Element*>(a) );
   else
      std::sort(index, index + n, CompareAsc<const Element*>(a) );
}
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/TypeTraits.hxx" 1 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/TypeTraits.hxx" 3
namespace ROOT {


namespace TypeTraits {


template <typename... Types>
struct TypeList {
   static constexpr std::size_t list_size = sizeof...(Types);
};
}

namespace Detail {
template <typename T> constexpr auto HasCallOp(int ) -> decltype(&T::operator(), true) { return true; }
template <typename T> constexpr bool HasCallOp(char ) { return false; }


template <typename T, bool HasCallOp = ROOT::Detail::HasCallOp<T>(0)>
struct CallableTraitsImpl {};


template <typename T>
struct CallableTraitsImpl<T, true> {
   using arg_types = typename CallableTraitsImpl<decltype(&T::operator())>::arg_types;
   using arg_types_nodecay = typename CallableTraitsImpl<decltype(&T::operator())>::arg_types_nodecay;
   using ret_type = typename CallableTraitsImpl<decltype(&T::operator())>::ret_type;
};


template <typename R, typename T, typename... Args>
struct CallableTraitsImpl<R (T::*)(Args...) const, false> {
   using arg_types = ROOT::TypeTraits::TypeList<std::decay_t<Args>...>;
   using arg_types_nodecay = ROOT::TypeTraits::TypeList<Args...>;
   using ret_type = R;
};


template <typename R, typename T, typename... Args>
struct CallableTraitsImpl<R (T::*)(Args...), false> {
   using arg_types = ROOT::TypeTraits::TypeList<std::decay_t<Args>...>;
   using arg_types_nodecay = ROOT::TypeTraits::TypeList<Args...>;
   using ret_type = R;
};


template <typename R, typename... Args>
struct CallableTraitsImpl<R (*)(Args...), false> {
   using arg_types = ROOT::TypeTraits::TypeList<std::decay_t<Args>...>;
   using arg_types_nodecay = ROOT::TypeTraits::TypeList<Args...>;
   using ret_type = R;
};


template <typename R, typename... Args>
struct CallableTraitsImpl<R(Args...), false> {
   using arg_types = ROOT::TypeTraits::TypeList<std::decay_t<Args>...>;
   using arg_types_nodecay = ROOT::TypeTraits::TypeList<Args...>;
   using ret_type = R;
};
}

namespace TypeTraits {


template <class T>
class IsSmartOrDumbPtr : public std::integral_constant<bool, std::is_pointer<T>::value> {
};

template <class P>
class IsSmartOrDumbPtr<std::shared_ptr<P>> : public std::true_type {
};

template <class P>
class IsSmartOrDumbPtr<std::unique_ptr<P>> : public std::true_type {
};


template<class T>
struct IsSignedNumeral : std::integral_constant<bool,
   std::is_integral<T>::value &&
   std::is_signed<T>::value &&
   !std::is_same<T, char>::value
> {};


template<class T>
struct IsUnsignedNumeral : std::integral_constant<bool,
   std::is_integral<T>::value &&
   !std::is_signed<T>::value &&
   !std::is_same<T, char>::value
> {};


template<class T>
using IsFloatNumeral = std::is_floating_point<T>;





template<typename F>
using CallableTraits = ROOT::Detail::CallableTraitsImpl<F>;


template <typename T, typename... Rest>
struct TakeFirstType {
   using type = T;
};

template <typename... Types>
using TakeFirstType_t = typename TakeFirstType<Types...>::type;



template <typename T, typename... Rest>
struct RemoveFirst {
   using type = TypeList<Rest...>;
};

template <typename... Args>
using RemoveFirst_t = typename RemoveFirst<Args...>::type;





template <typename T>
struct TakeFirstParameter {
   using type = void;
};

template <template <typename...> class Template, typename T, typename... Rest>
struct TakeFirstParameter<Template<T, Rest...>> {
   using type = T;
};

template <typename T>
using TakeFirstParameter_t = typename TakeFirstParameter<T>::type;



template <typename>
struct RemoveFirstParameter {
};

template <typename T, template <typename...> class U, typename... Rest>
struct RemoveFirstParameter<U<T, Rest...>> {
   using type = U<Rest...>;
};

template <typename T>
using RemoveFirstParameter_t = typename RemoveFirstParameter<T>::type;

template <typename T>
struct HasBeginAndEnd {

   template <typename V>
   using Begin_t = typename V::const_iterator (V::*)() const;

   template <typename V>
   using End_t = typename V::const_iterator (V::*)() const;

   template <typename V>
   static constexpr auto Check(int)
      -> decltype(static_cast<Begin_t<V>>(&V::begin), static_cast<End_t<V>>(&V::end), true)
   {
      return true;
   }

   template <typename V>
   static constexpr bool Check(...)
   {
      return false;
   }

   static constexpr bool const value = Check<T>(0);
};


template <typename F, typename... Args>

using InvokeResult_t = std::invoke_result_t<F, Args...>;




}
}
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdarg" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdarg" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include/stdarg.h" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cstdarg" 2 3






namespace std
{
  using ::va_list;
}
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 2 3







class TRegexp;
class TPRegexp;
class TString;
class TSubString;
class TObjArray;
class TVirtualMutex;
class TBuffer;
class TClass;
class TBufferFile;

TString operator+(const TString &s1, const TString &s2);
TString operator+(const TString &s, const char *cs);
TString operator+(const char *cs, const TString &s);
TString operator+(const TString &s, char c);
TString operator+(char c, const TString &s);
Bool_t operator==(const TString &s1, const TString &s2);
Bool_t operator==(const TString &s1, const char *s2);
Bool_t operator==(const TSubString &s1, const TSubString &s2);
Bool_t operator==(const TSubString &s1, const TString &s2);
Bool_t operator==(const TSubString &s1, const char *s2);
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 3
class TSubString {

friend class TStringLong;
friend class TString;

friend Bool_t operator==(const TSubString &s1, const TSubString &s2);
friend Bool_t operator==(const TSubString &s1, const TString &s2);
friend Bool_t operator==(const TSubString &s1, const char *s2);

private:
   TString &fStr;
   Ssiz_t fBegin;
   Ssiz_t fExtent;


   TSubString(const TString &s, Ssiz_t start, Ssiz_t len);

protected:
   void SubStringError(Ssiz_t, Ssiz_t, Ssiz_t) const;
   void AssertElement(Ssiz_t i) const;

public:
   TSubString(const TSubString &s)
     : fStr(s.fStr), fBegin(s.fBegin), fExtent(s.fExtent) { }

   TSubString &operator=(const char *s);
   TSubString &operator=(const TString &s);
   TSubString &operator=(const TSubString &s);
   char &operator()(Ssiz_t i);
   char &operator[](Ssiz_t i);
   char operator()(Ssiz_t i) const;
   char operator[](Ssiz_t i) const;

   operator std::string_view() const { return std::string_view(Data(),fExtent); }
   operator std::string() const { return std::string(Data(),fExtent); }

   const char *Data() const;
   Ssiz_t Length() const { return fExtent; }
   Ssiz_t Start() const { return fBegin; }
   TString& String() { return fStr; }
   void ToLower();
   void ToUpper();


   Bool_t IsNull() const { return fBegin == kNPOS; }
   int operator!() const { return fBegin == kNPOS; }
};







class TString {

friend class TStringLong;
friend class TSubString;
friend class TBufferFile;

friend TString operator+(const TString &s1, const TString &s2);
friend TString operator+(const TString &s, const char *cs);
friend TString operator+(const char *cs, const TString &s);
friend TString operator+(const TString &s, char c);
friend TString operator+(char c, const TString &s);

template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
operator+(TString s, T i);
template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
operator+(TString s, T u);
template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
operator+(TString s, T f);
template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
operator+(T i, const TString &s);
template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
operator+(T u, const TString &s);
template<class T>
friend typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
operator+(T f, const TString &s);

friend Bool_t operator==(const TString &s1, const TString &s2);
friend Bool_t operator==(const TString &s1, const char *s2);

friend std::strong_ordering operator<=>(const TString &s1, const TString &s2) {
   const int cmp = s1.CompareTo(s2);
   if (cmp == 0) return std::strong_ordering::equal;
   if (cmp < 0) return std::strong_ordering::less;
   return std::strong_ordering::greater;
}


private:

   enum { kShortMask = 0x01, kLongMask = 0x1 };




   struct LongStr_t
   {
      Ssiz_t fCap;
      Ssiz_t fSize;
      char *fData;
   };

   enum { kMinCap = (sizeof(LongStr_t) - 1)/sizeof(char) > 2 ?
                    (sizeof(LongStr_t) - 1)/sizeof(char) : 2 };

   struct ShortStr_t
   {
      unsigned char fSize;
      char fData[kMinCap];
   };

   union UStr_t { LongStr_t fL; ShortStr_t fS; };

   enum { kNwords = sizeof(UStr_t) / sizeof(Ssiz_t)};

   struct RawStr_t
   {
      Ssiz_t fWords[kNwords];
   };

   struct Rep_t
   {
      union
      {
         LongStr_t fLong;
         ShortStr_t fShort;
         RawStr_t fRaw;
      };
   };

protected:
   Rep_t fRep;


   TString(const char *a1, Ssiz_t n1, const char *a2, Ssiz_t n2);
   void AssertElement(Ssiz_t nc) const;
   Ssiz_t Clobber(Ssiz_t nc);
   void InitChar(char c);

   enum { kAlignment = 16 };
   static Ssiz_t Align(Ssiz_t s) { return (s + (kAlignment-1)) & ~(kAlignment-1); }
   static Ssiz_t Recommend(Ssiz_t s) { return (s < kMinCap ? kMinCap : Align(s+1)) - 1; }
   static Ssiz_t AdjustCapacity(Ssiz_t oldCap, Ssiz_t newCap);

private:
   Bool_t IsLong() const { return Bool_t(fRep.fShort.fSize & kShortMask); }

   void SetShortSize(Ssiz_t s) { fRep.fShort.fSize = (unsigned char)(s << 1); }
   Ssiz_t GetShortSize() const { return fRep.fShort.fSize >> 1; }




   void SetLongSize(Ssiz_t s) { fRep.fLong.fSize = s; }
   Ssiz_t GetLongSize() const { return fRep.fLong.fSize; }
   void SetSize(Ssiz_t s) { IsLong() ? SetLongSize(s) : SetShortSize(s); }
   void SetLongCap(Ssiz_t s) { fRep.fLong.fCap = kLongMask | s; }
   Ssiz_t GetLongCap() const { return fRep.fLong.fCap & ~kLongMask; }
   void SetLongPointer(char *p) { fRep.fLong.fData = p; }
   char *GetLongPointer() { return fRep.fLong.fData; }
   const char *GetLongPointer() const { return fRep.fLong.fData; }
   char *GetShortPointer() { return fRep.fShort.fData; }
   const char *GetShortPointer() const { return fRep.fShort.fData; }
   char *GetPointer() { return IsLong() ? GetLongPointer() : GetShortPointer(); }
   const char *GetPointer() const { return IsLong() ? GetLongPointer() : GetShortPointer(); }

   static Ssiz_t MaxSize() { return kMaxInt - 1; }



   void UnLink() const { if (IsLong()) delete [] fRep.fLong.fData; }
   void Zero() {
      Ssiz_t (&a)[kNwords] = fRep.fRaw.fWords;
      for (UInt_t i = 0; i < kNwords; ++i)
         a[i] = 0;
   }
   char *Init(Ssiz_t capacity, Ssiz_t nchar);
   void Clone(Ssiz_t nc);
   void FormImp(const char *fmt, va_list ap);
   UInt_t HashCase() const;
   UInt_t HashFoldCase() const;

public:
   enum EStripType { kLeading = 0x1, kTrailing = 0x2, kBoth = 0x3 };
   enum ECaseCompare { kExact, kIgnoreCase };
   static constexpr Ssiz_t kNPOS = ::kNPOS;
   using size_type = Ssiz_t;

   TString();
   explicit TString(Ssiz_t ic);
   TString(const TString &s);
   TString(TString &&s) noexcept;
   TString(const char *s);
   TString(const char *s, Ssiz_t n);
   TString(const std::string &s);
   TString(char c);
   TString(char c, Ssiz_t s);
   explicit TString(const std::string_view &sub);
   TString(const TSubString &sub);

   virtual ~TString();


   virtual void FillBuffer(char *&buffer) const;
   virtual void ReadBuffer(char *&buffer);
   virtual Int_t Sizeof() const;

   static TString *ReadString(TBuffer &b, const TClass *clReq);
   static void WriteString(TBuffer &b, const TString *a);

   friend TBuffer &operator<<(TBuffer &b, const TString *obj);


   Bool_t Gets(FILE *fp, Bool_t chop=kTRUE);
   void Puts(FILE *fp);


   operator const char*() const { return GetPointer(); }



   inline explicit operator std::string() const { return std::string(GetPointer(),Length()); }

   inline operator std::string_view() const { return std::string_view(GetPointer(),Length()); }


   TString &operator=(char s);
   TString &operator=(const char *s);
   TString &operator=(const TString &s);
   TString &operator=(TString &&s) noexcept;
   TString &operator=(const std::string &s);
   TString &operator=(const std::string_view &s);
   TString &operator=(const TSubString &s);
   TString &operator+=(const char *s);
   TString &operator+=(const TString &s);
   TString &operator+=(char c);

   template<class T>
   typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
              &operator+=(T i);
   template<class T>
   typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
              &operator+=(T u);
   template<class T>
   typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
              &operator+=(T f);


   char &operator[](Ssiz_t i);
   char &operator()(Ssiz_t i);
   char operator[](Ssiz_t i) const;
   char operator()(Ssiz_t i) const;
   TSubString operator()(Ssiz_t start, Ssiz_t len) const;
   TSubString operator()(const TRegexp &re) const;
   TSubString operator()(const TRegexp &re, Ssiz_t start) const;
   TSubString operator()(TPRegexp &re) const;
   TSubString operator()(TPRegexp &re, Ssiz_t start) const;
   TSubString SubString(const char *pat, Ssiz_t start = 0,
                           ECaseCompare cmp = kExact) const;


   TString &Append(const char *cs);
   TString &Append(const char *cs, Ssiz_t n);
   TString &Append(const TString &s);
   TString &Append(const TString &s, Ssiz_t n);
   TString &Append(char c, Ssiz_t rep = 1);
   Int_t Atoi() const;
   Long64_t Atoll() const;
   Double_t Atof() const;
   Bool_t BeginsWith(const char *s, ECaseCompare cmp = kExact) const;
   Bool_t BeginsWith(const TString &pat, ECaseCompare cmp = kExact) const;
   Ssiz_t Capacity() const { return (IsLong() ? GetLongCap() : kMinCap) - 1; }
   Ssiz_t Capacity(Ssiz_t n);
   TString &Chop();
   void Clear();
   int CompareTo(const char *cs, ECaseCompare cmp = kExact) const;
   int CompareTo(const TString &st, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const char *pat, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const TString &pat, ECaseCompare cmp = kExact) const;
   Bool_t Contains(const TRegexp &pat) const;
   Bool_t Contains(TPRegexp &pat) const;
   Int_t CountChar(Int_t c) const;
   TString Copy() const;
   const char *Data() const { return GetPointer(); }
   Bool_t EndsWith(const char *pat, ECaseCompare cmp = kExact) const;
   Bool_t EqualTo(const char *cs, ECaseCompare cmp = kExact) const;
   Bool_t EqualTo(const TString &st, ECaseCompare cmp = kExact) const;
   Ssiz_t First(char c) const;
   Ssiz_t First(const char *cs) const;
   void Form(const char *fmt, ...)

   __attribute__((format(printf, 2, 3)))

   ;
   UInt_t Hash(ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const char *pat, Ssiz_t i = 0,
                      ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const TString &s, Ssiz_t i = 0,
                      ECaseCompare cmp = kExact) const;
   Ssiz_t Index(const char *pat, Ssiz_t patlen, Ssiz_t i,
                      ECaseCompare cmp) const;
   Ssiz_t Index(const TString &s, Ssiz_t patlen, Ssiz_t i,
                      ECaseCompare cmp) const;
   Ssiz_t Index(const TRegexp &pat, Ssiz_t i = 0) const;
   Ssiz_t Index(const TRegexp &pat, Ssiz_t *ext, Ssiz_t i = 0) const;
   Ssiz_t Index(TPRegexp &pat, Ssiz_t i = 0) const;
   Ssiz_t Index(TPRegexp &pat, Ssiz_t *ext, Ssiz_t i = 0) const;
   TString &Insert(Ssiz_t pos, const char *s);
   TString &Insert(Ssiz_t pos, const char *s, Ssiz_t extent);
   TString &Insert(Ssiz_t pos, const TString &s);
   TString &Insert(Ssiz_t pos, const TString &s, Ssiz_t extent);
   Bool_t IsAscii() const;
   Bool_t IsAlpha() const;
   Bool_t IsAlnum() const;
   Bool_t IsDigit() const;
   Bool_t IsFloat() const;
   Bool_t IsHex() const;
   Bool_t IsBin() const;
   Bool_t IsOct() const;
   Bool_t IsDec() const;
   Bool_t IsInBaseN(Int_t base) const;
   Bool_t IsNull() const { return Length() == 0; }
   Bool_t IsWhitespace() const { return (Length() == CountChar(' ')); }
   Ssiz_t Last(char c) const;
   Ssiz_t Length() const { return IsLong() ? GetLongSize() : GetShortSize(); }
   Bool_t MaybeRegexp() const;
   Bool_t MaybeWildcard() const;
   TString MD5() const;
   TString &Prepend(const char *cs);
   TString &Prepend(const char *cs, Ssiz_t n);
   TString &Prepend(const TString &s);
   TString &Prepend(const TString &s, Ssiz_t n);
   TString &Prepend(char c, Ssiz_t rep = 1);
   std::istream &ReadFile(std::istream &str);
   std::istream &ReadLine(std::istream &str,
                         Bool_t skipWhite = kTRUE);
   std::istream &ReadString(std::istream &str);
   std::istream &ReadToDelim(std::istream &str, char delim = '\n');
   std::istream &ReadToken(std::istream &str);
   TString &Remove(Ssiz_t pos);
   TString &Remove(Ssiz_t pos, Ssiz_t n);
   TString &Remove(EStripType s, char c);
   TString &Replace(Ssiz_t pos, Ssiz_t n, const char *s);
   TString &Replace(Ssiz_t pos, Ssiz_t n, const char *s, Ssiz_t ns);
   TString &Replace(Ssiz_t pos, Ssiz_t n, const TString &s);
   TString &Replace(Ssiz_t pos, Ssiz_t n1, const TString &s, Ssiz_t n2);
   TString &ReplaceAll(const TString &s1, const TString &s2);
   TString &ReplaceAll(const TString &s1, const char *s2);
   TString &ReplaceAll(const char *s1, const TString &s2);
   TString &ReplaceAll(const char *s1, const char *s2);
   TString &ReplaceAll(const char *s1, Ssiz_t ls1, const char *s2, Ssiz_t ls2);
   TString &ReplaceSpecialCppChars();
   void Resize(Ssiz_t n);
   TSubString Strip(EStripType s = kTrailing, char c = ' ') const;
   TString &Swap(TString &other);
   void ToLower();
   void ToUpper();
   TObjArray *Tokenize(const TString &delim) const;
   Bool_t Tokenize(TString &tok, Ssiz_t &from, const char *delim = " ") const;
   std::string_view View() const { return std::string_view(GetPointer(),Length()); }


   static UInt_t Hash(const void *txt, Int_t ntxt);
   static Ssiz_t InitialCapacity(Ssiz_t ic = 15);
   static Ssiz_t MaxWaste(Ssiz_t mw = 15);
   static Ssiz_t ResizeIncrement(Ssiz_t ri = 16);
   static Ssiz_t GetInitialCapacity();
   static Ssiz_t GetResizeIncrement();
   static Ssiz_t GetMaxWaste();
   static TString Itoa ( Int_t value, Int_t base);
   static TString UItoa ( UInt_t value, Int_t base);
   static TString LLtoa ( Long64_t value, Int_t base);
   static TString ULLtoa (ULong64_t value, Int_t base);
   static TString BaseConvert(const TString& s_in, Int_t base_in, Int_t base_out);
   static TString Format(const char *fmt, ...)

   __attribute__((format(printf, 1, 2)))

   ;

   private: static_assert(std::is_integral<decltype(2)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TString") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 2; } virtual TClass *IsA() const { return TString::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TString::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TString::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 473; }
};


std::istream &operator>>(std::istream &str, TString &s);
std::ostream &operator<<(std::ostream &str, const TString &s);



TBuffer &operator>>(TBuffer &buf, TString *&sp);
TBuffer &operator<<(TBuffer &buf, const TString * sp);


inline std::string& operator+=(std::string &left, const TString &right)
{
   return left.append(right.Data());
}

TString ToLower(const TString &s);
TString ToUpper(const TString &s);

inline UInt_t Hash(const TString &s) { return s.Hash(); }
inline UInt_t Hash(const TString *s) { return s->Hash(); }
       UInt_t Hash(const char *s);

extern char *Form(const char *fmt, ...)

__attribute__((format(printf, 1, 2)))

;
extern void Printf(const char *fmt, ...)

__attribute__((format(printf, 1, 2)))

;
extern char *Strip(const char *str, char c = ' ');
extern char *StrDup(const char *str);
extern char *Compress(const char *str);
extern int EscChar(const char *src, char *dst, int dstlen, char *specchars,
                     char escchar);
extern int UnEscChar(const char *src, char *dst, int dstlen, char *specchars,
                       char escchar);
# 527 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 3
template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
operator+(TString s, T i)
{ return s += i; }

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
operator+(TString s, T u)
{ return s += u; }

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
operator+(TString s, T f)
{ return s += f; }

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
operator+(T i, const TString &s)
{
    char buffer[32];

    snprintf(buffer, sizeof(buffer), "%lld", static_cast<Long64_t>(i));
    return TString(buffer, strlen(buffer), s.Data(), s.Length());
}

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
operator+(T u, const TString &s)
{
    char buffer[32];

    snprintf(buffer, sizeof(buffer), "%llu", static_cast<ULong64_t>(u));
    return TString(buffer, strlen(buffer), s.Data(), s.Length());
}

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
operator+(T f, const TString &s)
{
    char buffer[32];

    snprintf(buffer, sizeof(buffer), "%.17Lg", static_cast<LongDouble_t>(f));
    return TString(buffer, strlen(buffer), s.Data(), s.Length());
}

inline TString &TString::Append(const char *cs)
{ return Replace(Length(), 0, cs, cs ? (Ssiz_t)strlen(cs) : 0); }

inline TString &TString::Append(const char *cs, Ssiz_t n)
{ return Replace(Length(), 0, cs, n); }

inline TString &TString::Append(const TString &s)
{ return Replace(Length(), 0, s.Data(), s.Length()); }

inline TString &TString::Append(const TString &s, Ssiz_t n)
{ return Replace(Length(), 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::operator+=(const char *cs)
{ return Append(cs, cs ? (Ssiz_t)strlen(cs) : 0); }

inline TString &TString::operator+=(const TString &s)
{ return Append(s.Data(), s.Length()); }

inline TString &TString::operator+=(char c)
{ return Append(c); }

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsSignedNumeral<T>::value,TString>::type
&TString::operator+=(T i)
{
   char buffer[32];

   snprintf(buffer, sizeof(buffer), "%lld", static_cast<Long64_t>(i));
   return operator+=(buffer);
}

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsUnsignedNumeral<T>::value,TString>::type
&TString::operator+=(T u)
{
   char buffer[32];

   snprintf(buffer, sizeof(buffer), "%llu", static_cast<ULong64_t>(u));
   return operator+=(buffer);
}

template<class T>
inline typename std::enable_if<ROOT::TypeTraits::IsFloatNumeral<T>::value,TString>::type
&TString::operator+=(T f)
{
   char buffer[32];

   snprintf(buffer, sizeof(buffer), "%.17Lg", static_cast<LongDouble_t>(f));
   return operator+=(buffer);
}

inline Bool_t TString::BeginsWith(const char *s, ECaseCompare cmp) const
{ return Index(s, s ? (Ssiz_t)strlen(s) : (Ssiz_t)0, (Ssiz_t)0, cmp) == 0; }

inline Bool_t TString::BeginsWith(const TString &pat, ECaseCompare cmp) const
{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) == 0; }

inline Bool_t TString::Contains(const TString &pat, ECaseCompare cmp) const
{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) != kNPOS; }

inline Bool_t TString::Contains(const char *s, ECaseCompare cmp) const
{ return Index(s, s ? (Ssiz_t)strlen(s) : 0, (Ssiz_t)0, cmp) != kNPOS; }





inline Bool_t TString::Contains(const TRegexp &pat) const
{ return Index(pat, (Ssiz_t)0) != kNPOS; }

inline Bool_t TString::Contains(TPRegexp &pat) const
{ return Index(pat, (Ssiz_t)0) != kNPOS; }

inline Bool_t TString::EqualTo(const char *cs, ECaseCompare cmp) const
{ return (CompareTo(cs, cmp) == 0) ? kTRUE : kFALSE; }

inline Bool_t TString::EqualTo(const TString &st, ECaseCompare cmp) const
{ return (CompareTo(st, cmp) == 0) ? kTRUE : kFALSE; }

inline Ssiz_t TString::Index(const char *s, Ssiz_t i, ECaseCompare cmp) const
{ return Index(s, s ? (Ssiz_t)strlen(s) : 0, i, cmp); }

inline Ssiz_t TString::Index(const TString &s, Ssiz_t i, ECaseCompare cmp) const
{ return Index(s.Data(), s.Length(), i, cmp); }

inline Ssiz_t TString::Index(const TString &pat, Ssiz_t patlen, Ssiz_t i,
                             ECaseCompare cmp) const
{ return Index(pat.Data(), patlen, i, cmp); }

inline TString &TString::Insert(Ssiz_t pos, const char *cs)
{ return Replace(pos, 0, cs, cs ? (Ssiz_t)strlen(cs) : 0); }

inline TString &TString::Insert(Ssiz_t pos, const char *cs, Ssiz_t n)
{ return Replace(pos, 0, cs, n); }

inline TString &TString::Insert(Ssiz_t pos, const TString &s)
{ return Replace(pos, 0, s.Data(), s.Length()); }

inline TString &TString::Insert(Ssiz_t pos, const TString &s, Ssiz_t n)
{ return Replace(pos, 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::Prepend(const char *cs)
{ return Replace(0, 0, cs, cs ? (Ssiz_t)strlen(cs) : 0); }

inline TString &TString::Prepend(const char *cs, Ssiz_t n)
{ return Replace(0, 0, cs, n); }

inline TString &TString::Prepend(const TString &s)
{ return Replace(0, 0, s.Data(), s.Length()); }

inline TString &TString::Prepend(const TString &s, Ssiz_t n)
{ return Replace(0, 0, s.Data(), TMath::Min(n, s.Length())); }

inline TString &TString::Remove(Ssiz_t pos)
{ return Replace(pos, TMath::Max(0, Length()-pos), nullptr, 0); }

inline TString &TString::Remove(Ssiz_t pos, Ssiz_t n)
{ return Replace(pos, n, nullptr, 0); }

inline TString &TString::Chop()
{ return Remove(TMath::Max(0, Length()-1)); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n, const char *cs)
{ return Replace(pos, n, cs, cs ? (Ssiz_t)strlen(cs) : 0); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n, const TString& s)
{ return Replace(pos, n, s.Data(), s.Length()); }

inline TString &TString::Replace(Ssiz_t pos, Ssiz_t n1, const TString &s,
                                 Ssiz_t n2)
{ return Replace(pos, n1, s.Data(), TMath::Min(s.Length(), n2)); }

inline TString &TString::ReplaceAll(const TString &s1, const TString &s2)
{ return ReplaceAll(s1.Data(), s1.Length(), s2.Data(), s2.Length()) ; }

inline TString &TString::ReplaceAll(const TString &s1, const char *s2)
{ return ReplaceAll(s1.Data(), s1.Length(), s2, s2 ? (Ssiz_t)strlen(s2) : 0); }

inline TString &TString::ReplaceAll(const char *s1, const TString &s2)
{ return ReplaceAll(s1, s1 ? (Ssiz_t)strlen(s1) : 0, s2.Data(), s2.Length()); }

inline TString &TString::ReplaceAll(const char *s1,const char *s2)
{ return ReplaceAll(s1, s1 ? (Ssiz_t)strlen(s1) : 0, s2, s2 ? (Ssiz_t)strlen(s2) : 0); }

inline TString &TString::Swap(TString &other) {

   Rep_t tmp = other.fRep;
   other.fRep = fRep;
   fRep = tmp;
   return *this;
}

inline char &TString::operator()(Ssiz_t i)
{ return GetPointer()[i]; }

inline char TString::operator()(Ssiz_t i) const
{ return GetPointer()[i]; }

inline char &TString::operator[](Ssiz_t i)
{ AssertElement(i); return GetPointer()[i]; }

inline char TString::operator[](Ssiz_t i) const
{ AssertElement(i); return GetPointer()[i]; }

inline const char *TSubString::Data() const
{
# 752 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TString.h" 3
   return fStr.Data() + fBegin;
}


inline char TSubString::operator[](Ssiz_t i) const
{ AssertElement(i); return fStr.GetPointer()[fBegin+i]; }

inline char TSubString::operator()(Ssiz_t i) const
{ return fStr.GetPointer()[fBegin+i]; }

inline TSubString &TSubString::operator=(const TSubString &s)
{ fStr = s.fStr; fBegin = s.fBegin; fExtent = s.fExtent; return *this; }



inline Bool_t operator==(const TString &s1, const TString &s2)
{
   return ((s1.Length() == s2.Length()) &&
            !memcmp(s1.Data(), s2.Data(), s1.Length()));
}

inline Bool_t operator!=(const TString &s1, const TString &s2)
{ return !(s1 == s2); }

inline Bool_t operator<(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) < 0; }

inline Bool_t operator>(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) > 0; }

inline Bool_t operator<=(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) <= 0; }

inline Bool_t operator>=(const TString &s1, const TString &s2)
{ return s1.CompareTo(s2) >= 0; }


inline Bool_t operator!=(const TString &s1, const char *s2)
{ return !(s1 == s2); }

inline Bool_t operator<(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) < 0; }

inline Bool_t operator>(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) > 0; }

inline Bool_t operator<=(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) <= 0; }

inline Bool_t operator>=(const TString &s1, const char *s2)
{ return s1.CompareTo(s2) >= 0; }

inline Bool_t operator==(const char *s1, const TString &s2)
{ return (s2 == s1); }

inline Bool_t operator!=(const char *s1, const TString &s2)
{ return !(s2 == s1); }

inline Bool_t operator<(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) > 0; }

inline Bool_t operator>(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) < 0; }

inline Bool_t operator<=(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) >= 0; }

inline Bool_t operator>=(const char *s1, const TString &s2)
{ return s2.CompareTo(s1) <= 0; }





inline Bool_t operator==(const TString &s1, const TSubString &s2)
{ return (s2 == s1); }

inline Bool_t operator==(const char *s1, const TSubString &s2)
{ return (s2 == s1); }

inline Bool_t operator!=(const TSubString &s1, const char *s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TSubString &s1, const TString &s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TSubString &s1, const TSubString &s2)
{ return !(s1 == s2); }

inline Bool_t operator!=(const TString &s1, const TSubString &s2)
{ return !(s2 == s1); }

inline Bool_t operator!=(const char *s1, const TSubString &s2)
{ return !(s2 == s1); }

namespace llvm {
   class raw_ostream;
}

namespace cling {
  std::string printValue(const TString* val);
  std::string printValue(const TSubString* val);
  std::string printValue(const std::string_view* val);
}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualMutex.h" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualMutex.h" 3
class TVirtualMutex;


 extern TVirtualMutex *gGlobalMutex;

class TVirtualMutex {

public:
   TVirtualMutex(Bool_t = kFALSE) { }
   virtual ~TVirtualMutex() { }

   virtual Int_t Lock() = 0;
   virtual Int_t TryLock() = 0;
   virtual Int_t UnLock() = 0;
   virtual Int_t CleanUp() = 0;
   Int_t Acquire() { return Lock(); }
   Int_t Release() { return UnLock(); }

   virtual TVirtualMutex *Factory(Bool_t = kFALSE) = 0;

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TVirtualMutex") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } virtual TClass *IsA() const { return TVirtualMutex::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TVirtualMutex::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TVirtualMutex::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualMutex.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 47; }
};
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualMutex.h" 3
class TLockGuard {

private:
   TVirtualMutex *fMutex{nullptr};

   TLockGuard(const TLockGuard&) = delete;
   TLockGuard& operator=(const TLockGuard&) = delete;

public:
   TLockGuard(TVirtualMutex *mutex)
     : fMutex(mutex) { if (fMutex) fMutex->Lock(); }
   Int_t UnLock() {
      if (!fMutex) return 0;
      auto tmp = fMutex;
      fMutex = nullptr;
      return tmp->UnLock();
   }
   ~TLockGuard() { if (fMutex) fMutex->UnLock(); }

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TLockGuard") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const { return TLockGuard::Class(); } void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TLockGuard::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TLockGuard::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualMutex.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) ; static int DeclFileLine() { return 89; }
};
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h" 2 3



namespace ROOT {

class TVirtualRWMutex;




 extern TVirtualRWMutex *gCoreMutex;

class TVirtualRWMutex : public TVirtualMutex {

public:




   class Hint_t;




   struct State {
      virtual ~State();
   };

   struct StateAndRecurseCount {

      std::unique_ptr<ROOT::TVirtualRWMutex::State> fState;




      Int_t fRecurseCount = 0;

      operator bool() const { return (bool)fState; }
   };




   struct StateDelta {
      virtual ~StateDelta();
   };

   virtual Hint_t *ReadLock() = 0;
   virtual void ReadUnLock(Hint_t *) = 0;
   virtual Hint_t *WriteLock() = 0;
   virtual void WriteUnLock(Hint_t *) = 0;

   Int_t Lock() override { WriteLock(); return 1; }
   Int_t TryLock() override { WriteLock(); return 1; }
   Int_t UnLock() override { WriteUnLock(nullptr); return 1; }
   Int_t CleanUp() override { WriteUnLock(nullptr); return 1; }

   virtual std::unique_ptr<State> GetStateBefore() = 0;
   virtual std::unique_ptr<StateDelta> Rewind(const State& earlierState) = 0;
   virtual void Apply(std::unique_ptr<StateDelta> &&delta) = 0;

   TVirtualRWMutex *Factory(Bool_t = kFALSE) override = 0;

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TVirtualRWMutex") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const override { return TVirtualRWMutex::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TVirtualRWMutex::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TVirtualRWMutex::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 90; }
};
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h" 3
class TReadLockGuard {

private:
   TVirtualRWMutex *const fMutex;
   TVirtualRWMutex::Hint_t *fHint;

   TReadLockGuard(const TReadLockGuard&) = delete;
   TReadLockGuard& operator=(const TReadLockGuard&) = delete;

public:
   TReadLockGuard(TVirtualRWMutex *mutex) : fMutex(mutex), fHint(nullptr) {
      if (fMutex) fHint = fMutex->ReadLock();
   }

   ~TReadLockGuard() { if (fMutex) fMutex->ReadUnLock(fHint); }

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TReadLockGuard") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const { return TReadLockGuard::Class(); } void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TReadLockGuard::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TReadLockGuard::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) ; static int DeclFileLine() { return 128; }
};

class TWriteLockGuard {

private:
   TVirtualRWMutex *const fMutex;
   TVirtualRWMutex::Hint_t *fHint;

   TWriteLockGuard(const TWriteLockGuard&) = delete;
   TWriteLockGuard& operator=(const TWriteLockGuard&) = delete;

public:
   TWriteLockGuard(TVirtualRWMutex *mutex) : fMutex(mutex), fHint(nullptr) {
      if (fMutex) fHint = fMutex->WriteLock();
   }

   ~TWriteLockGuard() { if (fMutex) fMutex->WriteUnLock(fHint); }

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TWriteLockGuard") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const { return TWriteLockGuard::Class(); } void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TWriteLockGuard::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TWriteLockGuard::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TVirtualRWMutex.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) ; static int DeclFileLine() { return 147; }
};

}
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RSpan.hxx" 1 3
# 17 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RSpan.hxx" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/span.hxx" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/span.hxx" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 2 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);

  template<typename _Type, size_t _Extent>
    class span;

  namespace __detail
  {
    template<typename _Tp>
      inline constexpr bool __is_span = false;

    template<typename _Tp, size_t _Num>
      inline constexpr bool __is_span<span<_Tp, _Num>> = true;

    template<typename _Tp>
      inline constexpr bool __is_std_array = false;

    template<typename _Tp, size_t _Num>
      inline constexpr bool __is_std_array<std::array<_Tp, _Num>> = true;

    template<size_t _Extent>
      class __extent_storage
      {
      public:

 constexpr
 __extent_storage([[maybe_unused]] size_t __n) noexcept
 { do { if (std::__is_constant_evaluated() && !bool(__n == _Extent)) std::__glibcxx_assert_fail(); } while (false); }


 consteval
 __extent_storage(integral_constant<size_t, _Extent>) noexcept
 { }


 template<size_t _Gob>
   __extent_storage(integral_constant<size_t, _Gob>) = delete;

 [[__gnu__::__always_inline__]]
 static constexpr size_t
 _M_extent() noexcept
 { return _Extent; }
      };

    template<>
      class __extent_storage<dynamic_extent>
      {
      public:
 [[__gnu__::__always_inline__]]
 constexpr
 __extent_storage(size_t __extent) noexcept
 : _M_extent_value(__extent)
 { }

 [[__gnu__::__always_inline__]]
 constexpr size_t
 _M_extent() const noexcept
 { return this->_M_extent_value; }

      private:
 size_t _M_extent_value;
      };

    template<typename _Type> struct __span_ptr { _Type* const _M_ptr; };

  }

  template<typename _Type, size_t _Extent = dynamic_extent>
    class span
    {
      template<size_t _Offset, size_t _Count>
 static constexpr size_t
 _S_subspan_extent()
 {
   if constexpr (_Count != dynamic_extent)
     return _Count;
   else if constexpr (extent != dynamic_extent)
     return _Extent - _Offset;
   else
     return dynamic_extent;
 }



      template<typename _Tp, size_t _ArrayExtent>
 requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
 using __is_compatible_array = __is_array_convertible<_Type, _Tp>;

      template<typename _Ref>
 using __is_compatible_ref
   = __is_array_convertible<_Type, remove_reference_t<_Ref>>;


      struct __iter_tag;

      template<size_t _Nm>
 static inline constexpr integral_constant<size_t, _Nm> __v{};

    public:

      using element_type = _Type;
      using value_type = remove_cv_t<_Type>;
      using size_type = size_t;
      using difference_type = ptrdiff_t;
      using pointer = _Type*;
      using const_pointer = const _Type*;
      using reference = element_type&;
      using const_reference = const element_type&;
      using iterator = __gnu_cxx::__normal_iterator<pointer, __iter_tag>;
      using reverse_iterator = std::reverse_iterator<iterator>;






      static constexpr size_t extent = _Extent;



      constexpr
      span() noexcept
      requires (_Extent == dynamic_extent || _Extent == 0)
      : _M_ptr(nullptr), _M_extent(__v<0>)
      { }

      template<contiguous_iterator _It>
 requires __is_compatible_ref<iter_reference_t<_It>>::value
 constexpr explicit(extent != dynamic_extent)
 span(_It __first, size_type __count)
 noexcept
 : _M_ptr(std::to_address(__first)), _M_extent(__count)
 { ; }

      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
 requires __is_compatible_ref<iter_reference_t<_It>>::value
   && (!is_convertible_v<_End, size_type>)
 constexpr explicit(extent != dynamic_extent)
 span(_It __first, _End __last)
 noexcept(noexcept(__last - __first))
 : _M_ptr(std::to_address(__first)),
   _M_extent(static_cast<size_type>(__last - __first))
 { ; }

      template<size_t _ArrayExtent>
 requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
 constexpr
 span(type_identity_t<element_type> (&__arr)[_ArrayExtent]) noexcept
 : _M_ptr(__arr), _M_extent(__v<_ArrayExtent>)
 { }

      template<typename _Tp, size_t _ArrayExtent>
 requires __is_compatible_array<_Tp, _ArrayExtent>::value
 constexpr
 span(array<_Tp, _ArrayExtent>& __arr) noexcept
 : _M_ptr(__arr.data()), _M_extent(__v<_ArrayExtent>)
 { }

      template<typename _Tp, size_t _ArrayExtent>
 requires __is_compatible_array<const _Tp, _ArrayExtent>::value
 constexpr
 span(const array<_Tp, _ArrayExtent>& __arr) noexcept
 : _M_ptr(__arr.data()), _M_extent(__v<_ArrayExtent>)
 { }

      template<typename _Range>
 requires (!__detail::__is_span<remove_cvref_t<_Range>>)
   && (!__detail::__is_std_array<remove_cvref_t<_Range>>)
   && (!is_array_v<remove_cvref_t<_Range>>)
   && ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
   && (ranges::borrowed_range<_Range> || is_const_v<element_type>)
   && __is_compatible_ref<ranges::range_reference_t<_Range>>::value
 constexpr explicit(extent != dynamic_extent)
 span(_Range&& __range)
 noexcept(noexcept(ranges::data(__range))
    && noexcept(ranges::size(__range)))
 : _M_ptr(ranges::data(__range)), _M_extent(ranges::size(__range))
 { }
# 247 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 3
      constexpr
      span(const span&) noexcept = default;

      template<typename _OType, size_t _OExtent>
 requires (_Extent == dynamic_extent || _OExtent == dynamic_extent
    || _Extent == _OExtent)
   && (__is_array_convertible<_Type, _OType>::value)
 constexpr
 explicit(extent != dynamic_extent && _OExtent == dynamic_extent)
 span(const span<_OType, _OExtent>& __s) noexcept
 : _M_ptr(__s.data()), _M_extent(__s.size())
 { }

      constexpr span&
      operator=(const span&) noexcept = default;



      [[nodiscard]]
      constexpr size_type
      size() const noexcept
      { return this->_M_extent._M_extent(); }

      [[nodiscard]]
      constexpr size_type
      size_bytes() const noexcept
      { return this->_M_extent._M_extent() * sizeof(element_type); }

      [[nodiscard]]
      constexpr bool
      empty() const noexcept
      { return size() == 0; }



      [[nodiscard]]
      constexpr reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_ptr;
      }

      [[nodiscard]]
      constexpr reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!empty())) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_ptr + (size() - 1));
      }

      [[nodiscard]]
      constexpr reference
      operator[](size_type __idx) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__idx < size())) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_ptr + __idx);
      }
# 318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 3
      [[nodiscard]]
      constexpr pointer
      data() const noexcept
      { return this->_M_ptr; }



      [[nodiscard]]
      constexpr iterator
      begin() const noexcept
      { return iterator(this->_M_ptr); }

      [[nodiscard]]
      constexpr iterator
      end() const noexcept
      { return iterator(this->_M_ptr + this->size()); }

      [[nodiscard]]
      constexpr reverse_iterator
      rbegin() const noexcept
      { return reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr reverse_iterator
      rend() const noexcept
      { return reverse_iterator(this->begin()); }
# 369 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/span" 3
      template<size_t _Count>
 [[nodiscard]]
 constexpr span<element_type, _Count>
 first() const noexcept
 {
   if constexpr (_Extent == dynamic_extent)
     do { if (std::__is_constant_evaluated() && !bool(_Count <= size())) std::__glibcxx_assert_fail(); } while (false);
   else
     static_assert(_Count <= extent);
   using _Sp = span<element_type, _Count>;
   return _Sp(_SizedPtr{this->data()});
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      first(size_type __count) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__count <= size())) std::__glibcxx_assert_fail(); } while (false);
 return span<element_type>(this->data(), __count);
      }

      template<size_t _Count>
 [[nodiscard]]
 constexpr span<element_type, _Count>
 last() const noexcept
 {
   if constexpr (_Extent == dynamic_extent)
     do { if (std::__is_constant_evaluated() && !bool(_Count <= size())) std::__glibcxx_assert_fail(); } while (false);
   else
     static_assert(_Count <= extent);
   using _Sp = span<element_type, _Count>;
   return _Sp(_SizedPtr{this->data() + (this->size() - _Count)});
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      last(size_type __count) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__count <= size())) std::__glibcxx_assert_fail(); } while (false);
 return span<element_type>(this->data() + (this->size() - __count),
      __count);
      }

      template<size_t _Offset, size_t _Count = dynamic_extent>
 [[nodiscard]]
 constexpr auto
 subspan() const noexcept
 -> span<element_type, _S_subspan_extent<_Offset, _Count>()>
 {
   if constexpr (_Extent == dynamic_extent)
     {
       do { if (std::__is_constant_evaluated() && !bool(_Offset <= size())) std::__glibcxx_assert_fail(); } while (false);
     }
   else
     static_assert(_Offset <= extent);

   using _Sp = span<element_type, _S_subspan_extent<_Offset, _Count>()>;

   if constexpr (_Count == dynamic_extent)
     return _Sp(this->data() + _Offset, this->size() - _Offset);
   else
     {
       if constexpr (_Extent == dynamic_extent)
  {
    do { if (std::__is_constant_evaluated() && !bool(_Count <= size())) std::__glibcxx_assert_fail(); } while (false);
    do { if (std::__is_constant_evaluated() && !bool(_Count <= (size() - _Offset))) std::__glibcxx_assert_fail(); } while (false);
  }
       else
  {
    static_assert(_Count <= extent);
    static_assert(_Count <= (extent - _Offset));
  }
       return _Sp(_SizedPtr{this->data() + _Offset});
     }
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      subspan(size_type __offset, size_type __count = dynamic_extent) const
      noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__offset <= size())) std::__glibcxx_assert_fail(); } while (false);
 if (__count == dynamic_extent)
   __count = this->size() - __offset;
 else
   {
     do { if (std::__is_constant_evaluated() && !bool(__count <= size())) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated() && !bool(__offset + __count <= size())) std::__glibcxx_assert_fail(); } while (false);
   }
 return span<element_type>(this->data() + __offset, __count);
      }

    private:
      template<typename, size_t> friend class span;


      using _SizedPtr = __detail::__span_ptr<_Type>;


      [[__gnu__::__always_inline__]]
      constexpr explicit
      span(_SizedPtr __ptr) noexcept
      requires (extent != dynamic_extent)
      : _M_ptr(__ptr._M_ptr), _M_extent(__v<extent>)
      { }

      pointer _M_ptr;
      [[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
    };



  template<typename _Type, size_t _ArrayExtent>
    span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(const array<_Type, _ArrayExtent>&)
      -> span<const _Type, _ArrayExtent>;

  template<contiguous_iterator _Iter, typename _End>
    span(_Iter, _End)
      -> span<remove_reference_t<iter_reference_t<_Iter>>>;

  template<ranges::contiguous_range _Range>
    span(_Range &&)
      -> span<remove_reference_t<ranges::range_reference_t<_Range&>>>;

  template<typename _Type, size_t _Extent>
    [[nodiscard]]
    inline
    span<const byte, _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type)>
    as_bytes(span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<const byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type);
      return span<const byte, extent>{data, size};
    }

  template<typename _Type, size_t _Extent>
    requires (!is_const_v<_Type>)
    inline
    span<byte, _Extent == dynamic_extent
       ? dynamic_extent : _Extent * sizeof(_Type)>
    as_writable_bytes [[nodiscard]] (span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type);
      return span<byte, extent>{data, size};
    }

  namespace ranges
  {

    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
 enable_borrowed_range<span<_ElementType, _Extent>> = true;


    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
 enable_view<span<_ElementType, _Extent>> = true;
  }

}
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/span.hxx" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RSpan.hxx" 2 3
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 2 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iterator" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iterator" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stream_iterator.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stream_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;



      bool _M_ok;

    public:

      constexpr istream_iterator()
      noexcept(is_nothrow_default_constructible<_Tp>::value)
      : _M_stream(0), _M_value(), _M_ok(false) {}


      istream_iterator(istream_type& __s)
      : _M_stream(std::__addressof(__s)), _M_ok(true)
      { _M_read(); }

      constexpr
      istream_iterator(const istream_iterator& __obj)
      noexcept(is_nothrow_copy_constructible<_Tp>::value)
      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
        _M_ok(__obj._M_ok)
      { }


      constexpr
      istream_iterator(default_sentinel_t)
      noexcept(is_nothrow_default_constructible_v<_Tp>)
      : istream_iterator() { }



      istream_iterator& operator=(const istream_iterator&) = default;
      ~istream_iterator() = default;


      [[__nodiscard__]]
      const _Tp&
      operator*() const noexcept
      {


                        ;
 return _M_value;
      }

      [[__nodiscard__]]
      const _Tp*
      operator->() const noexcept
      { return std::__addressof((operator*())); }

      istream_iterator&
      operator++()
      {


                        ;
 _M_read();
 return *this;
      }

      istream_iterator
      operator++(int)
      {


                        ;
 istream_iterator __tmp = *this;
 _M_read();
 return __tmp;
      }

    private:
      bool
      _M_equal(const istream_iterator& __x) const noexcept
      {


 return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);
      }

      void
      _M_read()
      {
        if (_M_stream && !(*_M_stream >> _M_value))
          {
            _M_stream = 0;
            _M_ok = false;
          }
      }



      [[__nodiscard__]]
      friend bool
      operator==(const istream_iterator& __x, const istream_iterator& __y)
      noexcept
      { return __x._M_equal(__y); }
# 178 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stream_iterator.h" 3
      [[nodiscard]]
      friend bool
      operator==(const istream_iterator& __i, default_sentinel_t) noexcept
      { return !__i._M_stream; }

    };
# 196 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stream_iterator.h" 3
  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT> >
    class ostream_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:



      using difference_type = ptrdiff_t;

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


    private:
      ostream_type* _M_stream;
      const _CharT* _M_string;

    public:

      ostream_iterator(ostream_type& __s) noexcept
      : _M_stream(std::__addressof(__s)), _M_string(0) {}
# 231 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stream_iterator.h" 3
      ostream_iterator(ostream_type& __s, const _CharT* __c) noexcept
      : _M_stream(std::__addressof(__s)), _M_string(__c) { }


      ostream_iterator(const ostream_iterator& __obj) noexcept
      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }


      ostream_iterator& operator=(const ostream_iterator&) = default;




      ostream_iterator&
      operator=(const _Tp& __value)
      {


                        ;
 *_M_stream << __value;
 if (_M_string)
          *_M_stream << _M_string;
 return *this;
      }

      [[__nodiscard__]]
      ostream_iterator&
      operator*() noexcept
      { return *this; }

      ostream_iterator&
      operator++() noexcept
      { return *this; }

      ostream_iterator&
      operator++(int) noexcept
      { return *this; }
    };
#pragma GCC diagnostic pop




}
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iterator" 2 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iterator" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iterator" 2 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 2 3



namespace ROOT {
namespace Internal {

template <typename T>
struct RBaseType {
   using type = typename std::remove_pointer<typename std::decay<T>::type>::type;
};


template <typename T>
constexpr auto hasBeginEnd(int) -> decltype(std::begin(std::declval<T>()), std::end(std::declval<T>()), true)
{
   return true;
}

template <typename>
constexpr bool hasBeginEnd(...)
{
   return false;
}

template <typename T, typename WrappedIterator_t, bool isDynamic>
class TypedIter {

public:
   TypedIter(WrappedIterator_t const &iter) : fIter{iter} {}

   TypedIter &operator++()
   {
      ++fIter;
      return *this;
   }
   TypedIter operator++(int)
   {
      TypedIter tmp(*this);
      operator++();
      return tmp;
   }
   bool operator==(const TypedIter &rhs) const { return fIter == rhs.fIter; }
   bool operator!=(const TypedIter &rhs) const { return fIter != rhs.fIter; }

   void swap(TypedIter &other) { fIter.swap(other.fIter); }




   T operator*()
   {
      if constexpr (isDynamic) {
         return dynamic_cast<T>(*fIter);
      } else {
         if constexpr (std::is_polymorphic<RBaseType<T>>::value) {
            (static_cast <bool> (dynamic_cast<T>(*fIter)) ? void (0) : __assert_fail ("dynamic_cast<T>(*fIter)", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx", 76, __extension__ __PRETTY_FUNCTION__));
         }
         return static_cast<T>(*fIter);
      }
   }

private:
   WrappedIterator_t fIter;
};

}






template <typename T, bool isDynamic, typename Range_t>
class RRangeCast {

public:
   RRangeCast(Range_t &&inputRange) : fInputRange{inputRange}
   {
      static_assert(ROOT::Internal::hasBeginEnd<Range_t>(0),
                    "Type with no `begin` or `end` method passed to `RRangeCast`");
   }

   using const_iterator = Internal::TypedIter<T, decltype(std::cbegin(std::declval<Range_t>())), isDynamic>;
   const_iterator begin() const { return std::cbegin(fInputRange); }
   const_iterator end() const { return std::cend(fInputRange); }

   using iterator = Internal::TypedIter<T, decltype(std::begin(std::declval<Range_t>())), isDynamic>;
   iterator begin() { return std::begin(fInputRange); }
   iterator end() { return std::end(fInputRange); }

private:
   Range_t fInputRange;
};
# 136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 3
template <typename T, typename Range_t>
RRangeCast<T, false, Range_t> RangeStaticCast(Range_t &&coll)
{
   return std::forward<Range_t>(coll);
}



template <typename T, typename U, std::size_t N>
RRangeCast<T, false, std::span<U>> RangeStaticCast(U (&arr)[N])
{
   return std::span<U>(arr, arr + N);
}
# 175 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RRangeCast.hxx" 3
template <typename T, typename Range_t>
RRangeCast<T, true, Range_t> RangeDynCast(Range_t &&coll)
{
   return std::forward<Range_t>(coll);
}



template <typename T, typename U, std::size_t N>
RRangeCast<T, true, std::span<U>> RangeDynCast(U (&arr)[N])
{
   return std::span<U>(arr, arr + N);
}

}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 2 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 2 3

class TClass;
class TObjectTable;
class TVirtualMutex;
class TIter;

const Bool_t kIterForward = kTRUE;
const Bool_t kIterBackward = !kIterForward;

 extern TVirtualMutex *gCollectionMutex;
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
class TCollection : public TObject {
# 133 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
private:
   static TCollection *fgCurrentCollection;
   static TObjectTable *fgGarbageCollection;
   static Bool_t fgEmptyingGarbage;
   static Int_t fgGarbageStack;

   TCollection(const TCollection &) = delete;
   void operator=(const TCollection &) = delete;

protected:
   enum EStatusBits {
      kIsOwner = (1ULL << (14)),

      kUseRWLock = (1ULL << (16))
   };

   TString fName;
   Int_t fSize;

   TCollection() : fName(), fSize(0) { }

   virtual void PrintCollectionHeader(Option_t* option) const;
   virtual const char* GetCollectionEntryName(TObject* entry) const;
   virtual void PrintCollectionEntry(TObject* entry, Option_t* option, Int_t recurse) const;

public:
   enum { kInitCapacity = 16, kInitHashTableCapacity = 17 };

   virtual ~TCollection();
   virtual void Add(TObject *obj) = 0;
   void AddVector(TObject *obj1, ...);
   virtual void AddAll(const TCollection *col);
   Bool_t AssertClass(TClass *cl) const;
   void Browse(TBrowser *b) override;
   Int_t Capacity() const { return fSize; }
   void Clear(Option_t *option="") override = 0;
   TObject *Clone(const char *newname="") const override;
   Int_t Compare(const TObject *obj) const override;
   Bool_t Contains(const char *name) const { return FindObject(name) != nullptr; }
   Bool_t Contains(const TObject *obj) const { return FindObject(obj) != nullptr; }
   void Delete(Option_t *option="") override = 0;
   void Draw(Option_t *option="") override;
   void Dump() const override;
   TObject *FindObject(const char *name) const override;
   TObject *operator()(const char *name) const;
   TObject *FindObject(const TObject *obj) const override;
   virtual Int_t GetEntries() const { return GetSize(); }
   const char *GetName() const override;
   virtual TObject **GetObjectRef(const TObject *obj) const = 0;


   virtual Int_t GetSize() const { return fSize; }
   virtual Int_t GrowBy(Int_t delta) const;
   ULong_t Hash() const override { return fName.Hash(); }
   Bool_t IsArgNull(const char *where, const TObject *obj) const;
   virtual Bool_t IsEmpty() const { return GetSize() <= 0; }
   Bool_t IsFolder() const override { return kTRUE; }
   Bool_t IsOwner() const { return TestBit(kIsOwner); }
   Bool_t IsSortable() const override { return kTRUE; }
   void ls(Option_t *option="") const override;
   Bool_t Notify() override;
   virtual TIterator *MakeIterator(Bool_t dir = kIterForward) const = 0;
   virtual TIterator *MakeReverseIterator() const { return MakeIterator(kIterBackward); }
   void Paint(Option_t *option="") override;
   void Print(Option_t *option="") const override;
   virtual void Print(Option_t *option, Int_t recurse) const;
   virtual void Print(Option_t *option, const char* wildcard, Int_t recurse=1) const;
   virtual void Print(Option_t *option, TPRegexp& regexp, Int_t recurse=1) const;
   void RecursiveRemove(TObject *obj) override;
   virtual TObject *Remove(TObject *obj) = 0;
   virtual void RemoveAll(TCollection *col);
   void RemoveAll() { Clear(); }
   void SetCurrentCollection();
   void SetName(const char *name) { fName = name; }
   virtual void SetOwner(Bool_t enable = kTRUE);
   virtual bool UseRWLock(Bool_t enable = true);
   Int_t Write(const char *name = nullptr, Int_t option = 0, Int_t bufsize = 0) override;
   Int_t Write(const char *name = nullptr, Int_t option = 0, Int_t bufsize = 0) const override;

   inline __attribute__((always_inline)) Bool_t IsUsingRWLock() const { return TestBit(TCollection::kUseRWLock); }

   static TCollection *GetCurrentCollection();
   static void StartGarbageCollection();
   static void GarbageCollect(TObject *obj);
   static void EmptyGarbageCollection();

   TIter begin() const;
   TIter end() const;

   private: static_assert(std::is_integral<decltype(3)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TCollection") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 3; } TClass *IsA() const override { return TCollection::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TCollection::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TCollection::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 222; }
};
# 235 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
class TIter {

private:
   TIterator *fIterator{nullptr};

protected:
   TIter() : fIterator(nullptr) { }

public:
   TIter(const TCollection *col, Bool_t dir = kIterForward)
         : fIterator(col ? col->MakeIterator(dir) : nullptr) { }
   TIter(TIterator *it) : fIterator(it) { }
   TIter(const TIter &iter);
   TIter &operator=(const TIter &rhs);
   virtual ~TIter() { { if (fIterator) { delete fIterator; fIterator = nullptr; } }; }
   TObject *operator()() { return Next(); }
   TObject *Next() { return fIterator ? fIterator->Next() : nullptr; }
   const TCollection *GetCollection() const { return fIterator ? fIterator->GetCollection() : nullptr; }
   Option_t *GetOption() const { return fIterator ? fIterator->GetOption() : ""; }
   void Reset() { if (fIterator) fIterator->Reset(); }
   TIter &operator++() { Next(); return *this; }
   Bool_t operator==(const TIter &aIter) const {
      if (fIterator == nullptr)
         return aIter.fIterator == nullptr || **aIter.fIterator == nullptr;
      if (aIter.fIterator == nullptr)
         return fIterator == nullptr || **fIterator == nullptr;
      return *fIterator == *aIter.fIterator;
   }
   Bool_t operator!=(const TIter &aIter) const {
      return !(*this == aIter);
   }
   TIter &operator=(TIterator *iter)
   {
      if (fIterator)
         delete fIterator;
      fIterator = iter;
      return *this;
   }
   TObject *operator*() const { return fIterator ? *(*fIterator): nullptr; }
   TIter &Begin();
   static TIter End();

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TIter") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } virtual TClass *IsA() const { return TIter::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(TIter::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 277; }
};

template <class T>
class TIterCategory: public TIter, public std::iterator_traits<typename T::Iterator_t> {

public:
   TIterCategory(const TCollection *col, Bool_t dir = kIterForward) : TIter(col, dir) { }
   TIterCategory(TIterator *it) : TIter(it) { }
   virtual ~TIterCategory() { }
   TIterCategory &Begin() { TIter::Begin(); return *this; }
   static TIterCategory End() { return TIterCategory(static_cast<TIterator*>(nullptr)); }
};


inline TIter TCollection::begin() const { return ++(TIter(this)); }
inline TIter TCollection::end() const { return TIter::End(); }

namespace ROOT {
namespace Internal {

const TCollection &EmptyCollection();
bool ContaineeInheritsFrom(TClass *cl, TClass *base);

}






namespace Detail {

template <typename T, bool isDynamic>
class TRangeCast : public ROOT::RRangeCast<T*, isDynamic, TCollection const&> {
public:
   TRangeCast(TCollection const& col) : ROOT::RRangeCast<T*, isDynamic, TCollection const&>{col} {
      static_assert(std::is_base_of<TObject, T>::value, "Containee type must inherit from TObject");
   }
   TRangeCast(TCollection const* col) : TRangeCast{col != nullptr ? *col : ROOT::Internal::EmptyCollection()} {}
};
# 336 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
template <typename T>
using TRangeStaticCast = TRangeCast<T, false>;

}
}
# 357 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TCollection.h" 3
template <typename T>
using TRangeDynCast = ROOT::Detail::TRangeCast<T, true>;
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSeqCollection.h" 2 3


class TSeqCollection : public TCollection {

protected:
   Bool_t fSorted;

   TSeqCollection() : fSorted(kFALSE) { }
   virtual void Changed() { fSorted = kFALSE; }

public:
   virtual ~TSeqCollection() { }
   void Add(TObject *obj) override { AddLast(obj); }
   virtual void AddFirst(TObject *obj) = 0;
   virtual void AddLast(TObject *obj) = 0;
   virtual void AddAt(TObject *obj, Int_t idx) = 0;
   virtual void AddAfter(const TObject *after, TObject *obj) = 0;
   virtual void AddBefore(const TObject *before, TObject *obj) = 0;
   virtual void RemoveFirst() { Remove(First()); }
   virtual void RemoveLast() { Remove(Last()); }
   virtual TObject *RemoveAt(Int_t idx) { return Remove(At(idx)); }
   virtual void RemoveAfter(TObject *after) { Remove(After(after)); }
   virtual void RemoveBefore(TObject *before) { Remove(Before(before)); }

   virtual TObject *At(Int_t idx) const = 0;
   virtual TObject *Before(const TObject *obj) const = 0;
   virtual TObject *After(const TObject *obj) const = 0;
   virtual TObject *First() const = 0;
   virtual TObject *Last() const = 0;
   Int_t LastIndex() const { return GetSize() - 1; }
   virtual Int_t GetLast() const;
   virtual Int_t IndexOf(const TObject *obj) const;
   virtual Bool_t IsSorted() const { return fSorted; }
   void UnSort() { fSorted = kFALSE; }
   Long64_t Merge(TCollection *list);

   static Int_t ObjCompare(TObject *a, TObject *b);
   static void QSort(TObject **a, Int_t first, Int_t last);
   static inline void QSort(TObject **a, TObject **b, Int_t first, Int_t last) { QSort(a, 1, &b, first, last); }
   static void QSort(TObject **a, Int_t nBs, TObject ***b, Int_t first, Int_t last);

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TSeqCollection") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const override { return TSeqCollection::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TSeqCollection::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TSeqCollection::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TSeqCollection.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 67; }
};
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h" 2 3



class TObjArrayIter;

class TObjArray : public TSeqCollection {

friend class TObjArrayIter;
friend class TClonesArray;

protected:
   TObject **fCont;
   Int_t fLowerBound;
   Int_t fLast;

   Bool_t BoundsOk(const char *where, Int_t at) const;
   void Init(Int_t s, Int_t lowerBound);
   Bool_t OutOfBoundsError(const char *where, Int_t i) const;
   Int_t GetAbsLast() const;

public:
   typedef TObjArrayIter Iterator_t;

   TObjArray(Int_t s = TCollection::kInitCapacity, Int_t lowerBound = 0);
   TObjArray(const TObjArray &a);
   virtual ~TObjArray();
   TObjArray& operator=(const TObjArray&);
   void Clear(Option_t *option="") override;
   virtual void Compress();
   void Delete(Option_t *option="") override;
   virtual void Expand(Int_t newSize);
   Int_t GetEntries() const override;
   Int_t GetEntriesFast() const {
      return GetAbsLast() + 1;
   }
   Int_t GetEntriesUnsafe() const;
   Int_t GetLast() const override;
   TObject **GetObjectRef() const { return fCont; };
   TObject **GetObjectRef(const TObject *obj) const override;
   Bool_t IsEmpty() const override { return GetAbsLast() == -1; }
   TIterator *MakeIterator(Bool_t dir = kIterForward) const override;

   void Add(TObject *obj) override { AddLast(obj); }
   void AddFirst(TObject *obj) override;
   void AddLast(TObject *obj) override;
   void AddAt(TObject *obj, Int_t idx) override;
   virtual void AddAtAndExpand(TObject *obj, Int_t idx);
   virtual Int_t AddAtFree(TObject *obj);
   void AddAfter(const TObject *after, TObject *obj) override;
   void AddBefore(const TObject *before, TObject *obj) override;
   TObject *FindObject(const char *name) const override;
   TObject *FindObject(const TObject *obj) const override;
   TObject *RemoveAt(Int_t idx) override;
   TObject *Remove(TObject *obj) override;
   virtual void RemoveRange(Int_t idx1, Int_t idx2);
   void RecursiveRemove(TObject *obj) override;

   TObject *At(Int_t idx) const override;
   TObject *UncheckedAt(Int_t i) const { return fCont[i-fLowerBound]; }
   TObject *Before(const TObject *obj) const override;
   TObject *After(const TObject *obj) const override;
   TObject *First() const override;
   TObject *Last() const override;
   virtual TObject *&operator[](Int_t i);
   virtual TObject *operator[](Int_t i) const;
   Int_t LowerBound() const { return fLowerBound; }
   Int_t IndexOf(const TObject *obj) const override;
   void SetLast(Int_t last);

   virtual void Randomize(Int_t ntimes=1);
   virtual void Sort(Int_t upto = kMaxInt);
   virtual Int_t BinarySearch(TObject *obj, Int_t upto = kMaxInt);

   private: static_assert(std::is_integral<decltype(3)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TObjArray") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 3; } TClass *IsA() const override { return TObjArray::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TObjArray::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TObjArray::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 99; }
};
# 117 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h" 3
class TObjArrayIter : public TIterator {

private:
   const TObjArray *fArray;
   Int_t fCurCursor;
   Int_t fCursor;
   Bool_t fDirection;

   TObjArrayIter() : fArray(nullptr), fCurCursor(0), fCursor(0), fDirection(kIterForward) { }

public:
   using iterator_category = std::bidirectional_iterator_tag;
   using value_type = TObject *;
   using difference_type = std::ptrdiff_t;
   using pointer = TObject **;
   using const_pointer = const TObject **;
   using reference = const TObject *&;

   TObjArrayIter(const TObjArray *arr, Bool_t dir = kIterForward);
   TObjArrayIter(const TObjArrayIter &iter);
   ~TObjArrayIter() { }
   TIterator &operator=(const TIterator &rhs) override;
   TObjArrayIter &operator=(const TObjArrayIter &rhs);

   const TCollection *GetCollection() const override { return fArray; }
   TObject *Next() override;
   void Reset() override;
   Bool_t operator!=(const TIterator &aIter) const override;
   Bool_t operator!=(const TObjArrayIter &aIter) const;
   TObject *operator*() const override;

   private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TObjArrayIter") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } TClass *IsA() const override { return TObjArrayIter::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TObjArrayIter::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TObjArrayIter::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TObjArray.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 148; }
};







inline Bool_t TObjArray::BoundsOk(const char *where, Int_t at) const
{
   return (at < fLowerBound || at-fLowerBound >= fSize)
                  ? OutOfBoundsError(where, at)
                  : kTRUE;
}

inline TObject *TObjArray::At(Int_t i) const
{

   int j = i-fLowerBound;
   if (j >= 0 && j < fSize) return fCont[j];
   BoundsOk("At", i);
   return nullptr;
}
# 12 "include/framework/database/IntraRunDependency.h" 2


namespace Belle2 {
  class EventMetaData;






  class IntraRunDependency: public TObject {
  public:






    explicit IntraRunDependency(TObject* object = 0, bool owner = true) {m_objects.SetOwner(owner); if (object) m_objects.Add(object);};





    virtual ~IntraRunDependency() {};






    TObject* getObject(const EventMetaData& event) const {return m_objects.At(getIndex(event));};





    TObject* getAnyObject() const {return m_objects.At(0);};





    bool isOwner() const {return m_objects.IsOwner();}







    virtual const std::vector<unsigned int>& getBoundaries() const = 0;

  protected:
    TObjArray m_objects;






    virtual int getIndex(const EventMetaData& event) const = 0;

    private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("IntraRunDependency") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return IntraRunDependency::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(IntraRunDependency::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { IntraRunDependency::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/database/IntraRunDependency.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 75; };
  };
}
# 12 "include/framework/database/DBStoreEntry.h" 2


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_set" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_set" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 154 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 175 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      template<typename _InputIterator>
 unordered_set(_InputIterator __first, _InputIterator __last,
        size_type __n = 0,
        const hasher& __hf = hasher(),
        const key_equal& __eql = key_equal(),
        const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_set(const unordered_set&) = default;


      unordered_set(unordered_set&&) = default;





      explicit
      unordered_set(const allocator_type& __a)
      : _M_h(__a)
      { }






      unordered_set(const unordered_set& __uset,
      const allocator_type& __a)
      : _M_h(__uset._M_h, __a)
      { }






      unordered_set(unordered_set&& __uset,
      const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__uset._M_h), __a)) )
      : _M_h(std::move(__uset._M_h), __a)
      { }
# 231 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      unordered_set&
      operator=(const unordered_set&) = default;


      unordered_set&
      operator=(unordered_set&&) = default;
# 336 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 372 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 428 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 454 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...); }
# 473 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 502 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 520 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 532 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 556 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_h.extract(__pos);
      }


      node_type
      extract(const key_type& __key)
      { return _M_h.extract(__key); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_h._M_reinsert_node(std::move(__nh)); }


      iterator
      insert(const_iterator, node_type&& __nh)
      { return _M_h._M_reinsert_node(std::move(__nh)).position; }
# 593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 615 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 633 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 656 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
 {
   if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>)
     if (std::__addressof(__source) == this) [[__unlikely__]]
       return;

   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)
 {
   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)
 {
   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(); }
# 727 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __k)
 -> decltype(_M_h._M_find_tr(__k))
 { return _M_h._M_find_tr(__k); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __k) const
 -> decltype(_M_h._M_find_tr(__k))
 { return _M_h._M_find_tr(__k); }
# 762 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __k) const
 -> decltype(_M_h._M_count_tr(__k))
 { return _M_h._M_count_tr(__k); }
# 782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __k) const
 -> decltype(_M_h._M_find_tr(__k), void(), true)
 { return _M_h._M_find_tr(__k) != _M_h.end(); }
# 803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __k)
 -> decltype(_M_h._M_equal_range_tr(__k))
 { return _M_h._M_equal_range_tr(__k); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __k) const
 -> decltype(_M_h._M_equal_range_tr(__k))
 { return _M_h._M_equal_range_tr(__k); }






      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }
# 865 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 885 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 926 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 937 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;
# 1074 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
      { }
# 1145 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 1171 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      unordered_multiset(initializer_list<value_type> __l,
    size_type __n = 0,
    const hasher& __hf = hasher(),
    const key_equal& __eql = key_equal(),
    const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }


      unordered_multiset&
      operator=(const unordered_multiset&) = default;


      unordered_multiset&
      operator=(unordered_multiset&&) = default;





      explicit
      unordered_multiset(const allocator_type& __a)
      : _M_h(__a)
      { }






      unordered_multiset(const unordered_multiset& __umset,
    const allocator_type& __a)
      : _M_h(__umset._M_h, __a)
      { }






      unordered_multiset(unordered_multiset&& __umset,
    const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__umset._M_h), __a)) )
      : _M_h(std::move(__umset._M_h), __a)
      { }

      unordered_multiset(size_type __n, const allocator_type& __a)
      : unordered_multiset(__n, hasher(), key_equal(), __a)
      { }

      unordered_multiset(size_type __n, const hasher& __hf,
    const allocator_type& __a)
      : unordered_multiset(__n, __hf, key_equal(), __a)
      { }

      template<typename _InputIterator>
 unordered_multiset(_InputIterator __first, _InputIterator __last,
      size_type __n,
      const allocator_type& __a)
 : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 unordered_multiset(_InputIterator __first, _InputIterator __last,
      size_type __n, const hasher& __hf,
      const allocator_type& __a)
 : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a)
 { }

      unordered_multiset(initializer_list<value_type> __l,
    size_type __n,
    const allocator_type& __a)
      : unordered_multiset(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_multiset(initializer_list<value_type> __l,
    size_type __n, const hasher& __hf,
    const allocator_type& __a)
      : unordered_multiset(__l, __n, __hf, key_equal(), __a)
      { }
# 1308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1344 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1392 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1414 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...); }
# 1427 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1453 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1482 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 1514 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_h.extract(__pos);
      }


      node_type
      extract(const key_type& __key)
      { return _M_h.extract(__key); }


      iterator
      insert(node_type&& __nh)
      { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }
# 1552 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1575 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1595 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }
# 1606 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      void
      clear() noexcept
      { _M_h.clear(); }
# 1619 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
 {
   if constexpr (is_same_v<_H2, _Hash> && is_same_v<_P2, _Pred>)
     if (std::__addressof(__source) == this) [[__unlikely__]]
       return;

   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)
 {
   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)
 {
   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(); }
# 1693 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 1724 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 1743 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 1762 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }






      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }
# 1824 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 1885 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>;
# 2020 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
  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); }
# 2048 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
  template<class _Value, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
        const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }
# 2066 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unordered_set.h" 3
  template<typename _Val, typename _Hash1, typename _Eq1, typename _Alloc,
    typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_set<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_set = std::unordered_set<_Tp...>;
      template<typename... _Tp>
 using unordered_multiset = std::unordered_multiset<_Tp...>;

      friend unordered_set<_Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
      { return __set._M_h; }

      static auto&
      _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
      { return __set._M_h; }
    };


  template<typename _Val, typename _Hash1, typename _Eq1, typename _Alloc,
    typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_set = std::unordered_set<_Tp...>;
      template<typename... _Tp>
 using unordered_multiset = std::unordered_multiset<_Tp...>;

      friend unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set)
      { return __set._M_h; }

      static auto&
      _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
      { return __set._M_h; }
    };



}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_set" 2 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_set" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/unordered_set" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_set
 = std::unordered_set<_Key, _Hash, _Pred,
        polymorphic_allocator<_Key>>;
    template<typename _Key, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_multiset
 = std::unordered_multiset<_Key, _Hash, _Pred,
      polymorphic_allocator<_Key>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
    typename _Predicate>
    inline typename unordered_set<_Key, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_set<_Key, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_set<_Key, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
    typename _Predicate>
    inline typename unordered_multiset<_Key, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_multiset<_Key, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_multiset<_Key, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 15 "include/framework/database/DBStoreEntry.h" 2

class TFile;

namespace Belle2 {
  class EventMetaData;
  class DBAccessorBase;
# 43 "include/framework/database/DBStoreEntry.h"
  class DBStoreEntry {
  public:

    enum EPayloadType {

      c_RawFile,

      c_ROOTFile,

      c_Object
    };
# 64 "include/framework/database/DBStoreEntry.h"
    DBStoreEntry(EPayloadType type, const std::string& name, const TClass* objClass, bool isArray, bool isRequired):
      m_payloadType(type), m_name(name), m_objClass(objClass), m_isArray(isArray), m_isRequired(isRequired) {}
# 76 "include/framework/database/DBStoreEntry.h"
    static DBStoreEntry fromObject(const std::string& name, const TObject* obj, bool isRequired);

    DBStoreEntry(const DBStoreEntry&) = delete;

    DBStoreEntry& operator=(const DBStoreEntry&) = delete;

    DBStoreEntry(DBStoreEntry&&) = default;



    ~DBStoreEntry();

    const std::string& getName() const { return m_name; }

    const std::string& getGlobaltag() const { return m_globaltag; }


    unsigned int getRevision() const { return m_revision; }

    IntervalOfValidity getIoV() const { return m_iov; }

    const std::string& getFilename() const { return m_filename; }


    const std::string& getChecksum() const { return m_checksum; }


    const TObject* getObject() const { return m_object; }

    const TFile* getTFile() const { return m_tfile; }

    const TClass* getClass() const { return m_objClass; }

    bool isArray() const { return m_isArray; }

    bool isRequired() const { return m_isRequired; }

    bool keepUntilExpired() const { return m_keep; }

    bool isIntraRunDependent() const { return (bool)m_intraRunDependency; }

    const std::vector<unsigned int> getIntraRunBoundaries() const { if (isIntraRunDependent()) return m_intraRunDependency->getBoundaries(); return std::vector<unsigned int> {}; }

    void registerAccessor(DBAccessorBase* object) { m_accessors.insert(object); }

    void removeAccessor(DBAccessorBase* object) { m_accessors.erase(object); }

  private:

    void resetPayload();
# 140 "include/framework/database/DBStoreEntry.h"
    void updatePayload(unsigned int revision, const IntervalOfValidity& iov, const std::string& filename, const std::string& checksum,
                       const std::string& globaltag, const EventMetaData& event);

    void loadPayload(const EventMetaData& event);





    void updateObject(const EventMetaData& event);





    void overrideObject(TObject* obj, const IntervalOfValidity& iov);

    TObject* releaseObject() { TObject* obj{nullptr}; std::swap(obj, m_object); return obj; }

    bool checkType(const TObject* object) const;

    bool checkType(EPayloadType type, const TClass* objClass, bool array, bool inverse = false) const;

    void notifyAccessors(bool onDestruction = false);

    void require() { m_isRequired = true; }

    const EPayloadType m_payloadType;

    const std::string m_name;

    const TClass* const m_objClass;

    const bool m_isArray;


    bool m_isRequired{false};


    bool m_keep{false};

    std::string m_globaltag{""};

    unsigned int m_revision{0};

    IntervalOfValidity m_iov{0, 0, 0, 0};

    std::string m_filename{""};

    std::string m_checksum;

    TFile* m_tfile{nullptr};

    TObject* m_object{nullptr};


    IntraRunDependency* m_intraRunDependency{nullptr};

    std::unordered_set<DBAccessorBase*> m_accessors;

    friend class DBStore;

    friend class Database;
  };
}
# 11 "include/framework/database/DBStore.h" 2
# 1 "include/framework/datastore/DataStore.h" 1
# 10 "include/framework/datastore/DataStore.h"
# 1 "include/framework/datastore/StoreEntry.h" 1
# 12 "include/framework/datastore/StoreEntry.h"
class TObject;
class TClass;
class TClonesArray;

namespace Belle2 {

  struct StoreEntry {
    StoreEntry() : isArray(false), dontWriteOut(false), objClass(nullptr), object(nullptr), ptr(nullptr), name() {};


    StoreEntry(bool isArray, TClass* cl, std::string name, bool dontWriteOut);


    void invalidate();

    void resetForGetEntry();

    void recoverFromNullObject();

    void recreate();

    TClonesArray* getPtrAsArray() const;

    bool isArray;
    bool dontWriteOut;
    TClass* objClass;






    TObject* object;


    TObject* ptr;

    std::string name;
  };
}
# 11 "include/framework/datastore/DataStore.h" 2
# 1 "include/framework/core/BitMask.h" 1
# 12 "include/framework/datastore/DataStore.h" 2







# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
  template<size_t _Nw>
    struct _Base_bitset
    {
      typedef unsigned long _WordT;


      _WordT _M_w[_Nw];

      constexpr _Base_bitset() noexcept
      : _M_w() { }


      constexpr _Base_bitset(unsigned long long __val) noexcept
      : _M_w{ _WordT(__val)



       } { }






      static constexpr size_t
      _S_whichword(size_t __pos) noexcept
      { return __pos / (8 * 8); }

      static constexpr size_t
      _S_whichbyte(size_t __pos) noexcept
      { return (__pos % (8 * 8)) / 8; }

      static constexpr size_t
      _S_whichbit(size_t __pos) noexcept
      { return __pos % (8 * 8); }

      static constexpr _WordT
      _S_maskbit(size_t __pos) noexcept
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      constexpr _WordT&
      _M_getword(size_t __pos) noexcept
      { return _M_w[_S_whichword(__pos)]; }

      constexpr _WordT
      _M_getword(size_t __pos) const noexcept
      { return _M_w[_S_whichword(__pos)]; }


      constexpr const _WordT*
      _M_getdata() const noexcept
      { return _M_w; }


                           _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];
      }

      constexpr void
      _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] |= __x._M_w[__i];
      }

      constexpr void
      _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] ^= __x._M_w[__i];
      }

      constexpr void
      _M_do_left_shift(size_t __shift) noexcept;

      constexpr void
      _M_do_right_shift(size_t __shift) noexcept;

      constexpr void
      _M_do_flip() noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~_M_w[__i];
      }

      constexpr void
      _M_do_set() noexcept
      {

 if (__builtin_is_constant_evaluated())
   {
     for (_WordT& __w : _M_w)
       __w = ~static_cast<_WordT>(0);;
     return;
   }

 __builtin_memset(_M_w, 0xFF, _Nw * sizeof(_WordT));
      }

      constexpr void
      _M_do_reset() noexcept
      {

 if (__builtin_is_constant_evaluated())
   {
     for (_WordT& __w : _M_w)
       __w = 0;
     return;
   }

 __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT));
      }

      constexpr bool
      _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
      {

 if (__builtin_is_constant_evaluated())
   {
     for (size_t __i = 0; __i < _Nw; ++__i)
       if (_M_w[__i] != __x._M_w[__i])
  return false;
     return true;
   }

 return !__builtin_memcmp(_M_w, __x._M_w, _Nw * sizeof(_WordT));
      }

      template<size_t _Nb>
        constexpr bool
        _M_are_all() const noexcept
        {
   for (size_t __i = 0; __i < _Nw - 1; __i++)
     if (_M_w[__i] != ~static_cast<_WordT>(0))
       return false;
   return _M_hiword() == (~static_cast<_WordT>(0)
     >> (_Nw * (8 * 8)
         - _Nb));
 }

      constexpr bool
      _M_is_any() const noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   if (_M_w[__i] != static_cast<_WordT>(0))
     return true;
 return false;
      }

      constexpr size_t
      _M_do_count() const noexcept
      {
 size_t __result = 0;
 for (size_t __i = 0; __i < _Nw; __i++)
   __result += __builtin_popcountl(_M_w[__i]);
 return __result;
      }

      constexpr unsigned long
      _M_do_to_ulong() const;


      constexpr unsigned long long
      _M_do_to_ullong() const;



      constexpr size_t
      _M_do_find_first(size_t) const noexcept;


      constexpr size_t
      _M_do_find_next(size_t, size_t) const noexcept;
    };


  template<size_t _Nw>
    constexpr void
    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept
    {
      if (__builtin_expect(__shift != 0, 1))
 {
   const size_t __wshift = __shift / (8 * 8);
   const size_t __offset = __shift % (8 * 8);

   if (__offset == 0)
     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
       _M_w[__n] = _M_w[__n - __wshift];
   else
     {
       const size_t __sub_offset = ((8 * 8)
        - __offset);
       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
        | (_M_w[__n - __wshift - 1] >> __sub_offset));
       _M_w[__wshift] = _M_w[0] << __offset;
     }

   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
 }
    }

  template<size_t _Nw>
    constexpr void
    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept
    {
      if (__builtin_expect(__shift != 0, 1))
 {
   const size_t __wshift = __shift / (8 * 8);
   const size_t __offset = __shift % (8 * 8);
   const size_t __limit = _Nw - __wshift - 1;

   if (__offset == 0)
     for (size_t __n = 0; __n <= __limit; ++__n)
       _M_w[__n] = _M_w[__n + __wshift];
   else
     {
       const size_t __sub_offset = ((8 * 8)
        - __offset);
       for (size_t __n = 0; __n < __limit; ++__n)
  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
        | (_M_w[__n + __wshift + 1] << __sub_offset));
       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
     }

   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
 }
    }

  template<size_t _Nw>
    constexpr unsigned long
    _Base_bitset<_Nw>::_M_do_to_ulong() const
    {
      for (size_t __i = 1; __i < _Nw; ++__i)
 if (_M_w[__i])
   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
      return _M_w[0];
    }


  template<size_t _Nw>
    constexpr unsigned long long
    _Base_bitset<_Nw>::_M_do_to_ullong() const
    {

      return _M_do_to_ulong();
# 348 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
    }


  template<size_t _Nw>
    constexpr size_t
    _Base_bitset<_Nw>::
    _M_do_find_first(size_t __not_found) const noexcept
    {
      for (size_t __i = 0; __i < _Nw; __i++)
 {
   _WordT __thisword = _M_w[__i];
   if (__thisword != static_cast<_WordT>(0))
     return (__i * (8 * 8)
      + __builtin_ctzl(__thisword));
 }

      return __not_found;
    }

  template<size_t _Nw>
    constexpr size_t
    _Base_bitset<_Nw>::
    _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
    {

      ++__prev;


      if (__prev >= _Nw * (8 * 8))
 return __not_found;


      size_t __i = _S_whichword(__prev);
      _WordT __thisword = _M_w[__i];


      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);

      if (__thisword != static_cast<_WordT>(0))
 return (__i * (8 * 8)
  + __builtin_ctzl(__thisword));


      __i++;
      for (; __i < _Nw; __i++)
 {
   __thisword = _M_w[__i];
   if (__thisword != static_cast<_WordT>(0))
     return (__i * (8 * 8)
      + __builtin_ctzl(__thisword));
 }

      return __not_found;
    }






  template<>
    struct _Base_bitset<1>
    {
      typedef unsigned long _WordT;
      _WordT _M_w;

      constexpr _Base_bitset() noexcept
      : _M_w(0)
      { }


      constexpr _Base_bitset(unsigned long long __val) noexcept



      : _M_w(__val)
      { }

      static constexpr size_t
      _S_whichword(size_t __pos) noexcept
      { return __pos / (8 * 8); }

      static constexpr size_t
      _S_whichbyte(size_t __pos) noexcept
      { return (__pos % (8 * 8)) / 8; }

      static constexpr size_t
      _S_whichbit(size_t __pos) noexcept
      { return __pos % (8 * 8); }

      static constexpr _WordT
      _S_maskbit(size_t __pos) noexcept
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      constexpr _WordT&
      _M_getword(size_t) noexcept
      { return _M_w; }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return _M_w; }


      constexpr const _WordT*
      _M_getdata() const noexcept
      { return &_M_w; }


      constexpr _WordT&
      _M_hiword() noexcept
      { return _M_w; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return _M_w; }

      constexpr void
      _M_do_and(const _Base_bitset<1>& __x) noexcept
      { _M_w &= __x._M_w; }

      constexpr void
      _M_do_or(const _Base_bitset<1>& __x) noexcept
      { _M_w |= __x._M_w; }

      constexpr void
      _M_do_xor(const _Base_bitset<1>& __x) noexcept
      { _M_w ^= __x._M_w; }

      constexpr void
      _M_do_left_shift(size_t __shift) noexcept
      { _M_w <<= __shift; }

      constexpr void
      _M_do_right_shift(size_t __shift) noexcept
      { _M_w >>= __shift; }

      constexpr void
      _M_do_flip() noexcept
      { _M_w = ~_M_w; }

      constexpr void
      _M_do_set() noexcept
      { _M_w = ~static_cast<_WordT>(0); }

      constexpr void
      _M_do_reset() noexcept
      { _M_w = 0; }

      constexpr bool
      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
      { return _M_w == __x._M_w; }

      template<size_t _Nb>
        constexpr bool
        _M_are_all() const noexcept
        { return _M_w == (~static_cast<_WordT>(0)
     >> ((8 * 8) - _Nb)); }

      constexpr bool
      _M_is_any() const noexcept
      { return _M_w != 0; }

      constexpr size_t
      _M_do_count() const noexcept
      { return __builtin_popcountl(_M_w); }

      constexpr unsigned long
      _M_do_to_ulong() const noexcept
      { return _M_w; }


      constexpr unsigned long long
      _M_do_to_ullong() const noexcept
      { return _M_w; }


      constexpr size_t
      _M_do_find_first(size_t __not_found) const noexcept
      {
        if (_M_w != 0)
          return __builtin_ctzl(_M_w);
        else
          return __not_found;
      }


      constexpr size_t
      _M_do_find_next(size_t __prev, size_t __not_found) const
 noexcept
      {
 ++__prev;
 if (__prev >= ((size_t) (8 * 8)))
   return __not_found;

 _WordT __x = _M_w >> __prev;
 if (__x != 0)
   return __builtin_ctzl(__x) + __prev;
 else
   return __not_found;
      }
    };






  template<>
    struct _Base_bitset<0>
    {
      typedef unsigned long _WordT;

      constexpr _Base_bitset() noexcept
      { }


      constexpr _Base_bitset(unsigned long long) noexcept



      { }

      static constexpr size_t
      _S_whichword(size_t __pos) noexcept
      { return __pos / (8 * 8); }

      static constexpr size_t
      _S_whichbyte(size_t __pos) noexcept
      { return (__pos % (8 * 8)) / 8; }

      static constexpr size_t
      _S_whichbit(size_t __pos) noexcept
      { return __pos % (8 * 8); }

      static constexpr _WordT
      _S_maskbit(size_t __pos) noexcept
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }







      __attribute__((__noreturn__))
      _WordT&
      _M_getword(size_t) noexcept
      { __throw_out_of_range(("_Base_bitset::_M_getword")); }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return 0; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return 0; }

      constexpr void
      _M_do_and(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_or(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_xor(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_left_shift(size_t) noexcept
      { }

      constexpr void
      _M_do_right_shift(size_t) noexcept
      { }

      constexpr void
      _M_do_flip() noexcept
      { }

      constexpr void
      _M_do_set() noexcept
      { }

      constexpr void
      _M_do_reset() noexcept
      { }




      constexpr bool
      _M_is_equal(const _Base_bitset<0>&) const noexcept
      { return true; }

      template<size_t _Nb>
        constexpr bool
        _M_are_all() const noexcept
        { return true; }

      constexpr bool
      _M_is_any() const noexcept
      { return false; }

      constexpr size_t
      _M_do_count() const noexcept
      { return 0; }

      constexpr unsigned long
      _M_do_to_ulong() const noexcept
      { return 0; }


      constexpr unsigned long long
      _M_do_to_ullong() const noexcept
      { return 0; }




      constexpr size_t
      _M_do_find_first(size_t) const noexcept
      { return 0; }

      constexpr size_t
      _M_do_find_next(size_t, size_t) const noexcept
      { return 0; }
    };



  template<size_t _Extrabits>
    struct _Sanitize
    {
      typedef unsigned long _WordT;

      static constexpr void
      _S_do_sanitize(_WordT& __val) noexcept
      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
    };

  template<>
    struct _Sanitize<0>
    {
      typedef unsigned long _WordT;

      static constexpr void
      _S_do_sanitize(_WordT) noexcept { }
    };


  template<size_t _Nb, bool = (_Nb < (8 * 8))>
    struct _Sanitize_val
    {
      static constexpr unsigned long long
      _S_do_sanitize_val(unsigned long long __val)
      { return __val; }
    };

  template<size_t _Nb>
    struct _Sanitize_val<_Nb, true>
    {
      static constexpr unsigned long long
      _S_do_sanitize_val(unsigned long long __val)
      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
    };

  namespace __bitset
  {

    template<typename _CharT>
      using __string = std::basic_string<_CharT>;
# 745 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
  }
# 811 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
# 868 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      class reference
      {
 friend class bitset;

 _WordT* _M_wp;
 size_t _M_bpos;


 reference(bitset& __b, size_t __pos) noexcept
 {
   _M_wp = &__b._M_getword(__pos);
   _M_bpos = _Base::_S_whichbit(__pos);
 }

      public:

 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)) { }
# 964 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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'));
 }
# 987 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
 }
# 1021 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      template<typename _CharT>
 [[__gnu__::__nonnull__]]

        explicit
 bitset(const _CharT* __str,
        typename __bitset::__string<_CharT>::size_type __n
   = __bitset::__string<_CharT>::npos,
        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
        : _Base()
        {

   if (!__str)
     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));

   using _Traits = typename __bitset::__string<_CharT>::traits_type;

   if (__n == __bitset::__string<_CharT>::npos)
     __n = _Traits::length(__str);
   _M_copy_from_ptr<_CharT, _Traits>(__str, __n, 0, __n, __zero, __one);
 }
# 1052 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1084 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
 else
   this->_M_do_reset();
 return *this;
      }
# 1116 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      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;
      }
# 1202 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1256 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      reference
      operator[](size_t __position)
      { return reference(*this, __position); }

      constexpr bool
      operator[](size_t __position) const
      { return _Unchecked_test(__position); }
# 1272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 1292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }




      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); }
# 1401 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      bool
      test(size_t __position) const
      {
 this->_M_check(__position, ("bitset::test"));
 return _Unchecked_test(__position);
      }
# 1415 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      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; }
# 1457 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      size_t
      _Find_first() const noexcept
      { return this->_M_do_find_first(_Nb); }
# 1469 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
      size_t
      _Find_next(size_t __prev) const noexcept
      { return this->_M_do_find_next(__prev, _Nb); }

    private:

      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, size_t _Nb2>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>&, bitset<_Nb2>&);

      template <class _CharT, class _Traits, size_t _Nb2>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>&, const bitset<_Nb2>&);

    };


  template<size_t _Nb>
    template<class _CharT, class _Traits>

      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);
 size_t __n = this->_Find_first();
 while (__n < _Nb)
   {
     __s[_Nb - __n - 1] = __one;
     __n = _Find_next(__n);
   }
      }
# 1559 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 1600 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bitset" 3
  template<class _CharT, class _Traits, size_t _Nb>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
    {
      typedef typename _Traits::char_type char_type;
      typedef std::basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::ios_base __ios_base;

      struct _Buffer
      {
 static constexpr bool _S_use_alloca() { return _Nb <= 256; }

 explicit _Buffer(_CharT* __p) : _M_ptr(__p) { }

 ~_Buffer()
 {
   if constexpr (!_S_use_alloca())
     delete[] _M_ptr;
 }

 _CharT* const _M_ptr;
      };
      _CharT* __ptr;
      if constexpr (_Buffer::_S_use_alloca())
 __ptr = (_CharT*)__builtin_alloca(_Nb);
      else
 __ptr = new _CharT[_Nb];
      const _Buffer __buf(__ptr);



      const char_type __zero = __is.widen('0');
      const char_type __one = __is.widen('1');

      typename __ios_base::iostate __state = __ios_base::goodbit;
      typename __istream_type::sentry __sentry(__is);
      if (__sentry)
 {
   try
     {
       for (size_t __i = _Nb; __i > 0; --__i)
  {
    static typename _Traits::int_type __eof = _Traits::eof();

    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
    if (_Traits::eq_int_type(__c1, __eof))
      {
        __state |= __ios_base::eofbit;
        break;
      }
    else
      {
        const char_type __c2 = _Traits::to_char_type(__c1);
        if (_Traits::eq(__c2, __zero))
   *__ptr++ = __zero;
        else if (_Traits::eq(__c2, __one))
   *__ptr++ = __one;
        else if (_Traits::
          eq_int_type(__is.rdbuf()->sputbackc(__c2),
        __eof))
   {
     __state |= __ios_base::failbit;
     break;
   }
      }
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __is._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __is._M_setstate(__ios_base::badbit); }
 }

      if constexpr (_Nb)
      {
 if (size_t __len = __ptr - __buf._M_ptr)
   __x.template _M_copy_from_ptr<_CharT, _Traits>(__buf._M_ptr, __len,
        0, __len,
        __zero, __one);
 else
   __state |= __ios_base::failbit;
      }
      if (__state)
 __is.setstate(__state);
      return __is;
    }

  template <class _CharT, class _Traits, size_t _Nb>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const bitset<_Nb>& __x)
    {
      std::basic_string<_CharT, _Traits> __tmp;



      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
      return __os << __tmp;
    }




}







namespace std __attribute__ ((__visibility__ ("default")))
{




  template<size_t _Nb>
    struct hash<std::bitset<_Nb>>
    : public __hash_base<size_t, std::bitset<_Nb>>
    {
      size_t
      operator()(const std::bitset<_Nb>& __b) const noexcept
      {
 const size_t __clength = (_Nb + 8 - 1) / 8;
 return std::_Hash_impl::hash(__b._M_getdata(), __clength);
      }
    };

  template<>
    struct hash<std::bitset<0>>
    : public __hash_base<size_t, std::bitset<0>>
    {
      size_t
      operator()(const std::bitset<0>&) const noexcept
      { return 0; }
    };


}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stack" 1 3
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stack" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stack" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/deque" 1 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/deque" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 1 3
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 115 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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() { }
# 164 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      template<typename _Iter,
        typename = _Require<is_same<_Self, const_iterator>,
       is_same<_Iter, iterator>>>
       _Deque_iterator(const _Iter& __x) noexcept
       : _M_cur(__x._M_cur), _M_first(__x._M_first),
  _M_last(__x._M_last), _M_node(__x._M_node) { }

      _Deque_iterator(const _Deque_iterator& __x) noexcept
       : _M_cur(__x._M_cur), _M_first(__x._M_first),
  _M_last(__x._M_last), _M_node(__x._M_node) { }

      _Deque_iterator& operator=(const _Deque_iterator&) = default;


      iterator
      _M_const_cast() const noexcept
      { return iterator(_M_cur, _M_node); }

      [[__nodiscard__]]
      reference
      operator*() const noexcept
      { return *_M_cur; }

      [[__nodiscard__]]
      pointer
      operator->() const noexcept
      { return _M_cur; }

      _Self&
      operator++() noexcept
      {
 ++_M_cur;
 if (_M_cur == _M_last)
   {
     _M_set_node(_M_node + 1);
     _M_cur = _M_first;
   }
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 ++*this;
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 if (_M_cur == _M_first)
   {
     _M_set_node(_M_node - 1);
     _M_cur = _M_last;
   }
 --_M_cur;
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 --*this;
 return __tmp;
      }

      _Self&
      operator+=(difference_type __n) noexcept
      {
 const difference_type __offset = __n + (_M_cur - _M_first);
 if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
   _M_cur += __n;
 else
   {
     const difference_type __node_offset =
       __offset > 0 ? __offset / difference_type(_S_buffer_size())
      : -difference_type((-__offset - 1)
           / _S_buffer_size()) - 1;
     _M_set_node(_M_node + __node_offset);
     _M_cur = _M_first + (__offset - __node_offset
     * difference_type(_S_buffer_size()));
   }
 return *this;
      }

      _Self&
      operator-=(difference_type __n) noexcept
      { return *this += -__n; }

      [[__nodiscard__]]
      reference
      operator[](difference_type __n) const noexcept
      { return *(*this + __n); }






      void
      _M_set_node(_Map_pointer __new_node) noexcept
      {
 _M_node = __new_node;
 _M_first = *__new_node;
 _M_last = _M_first + difference_type(_S_buffer_size());
      }

      [[__nodiscard__]]
      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_cur == __y._M_cur; }




      template<typename _RefR, typename _PtrR>
 [[__nodiscard__]]
 friend bool
 operator==(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
 noexcept
 { return __x._M_cur == __y._M_cur; }


      [[nodiscard]]
      friend strong_ordering
      operator<=>(const _Self& __x, const _Self& __y) noexcept
      {
 if (const auto __cmp = __x._M_node <=> __y._M_node; __cmp != 0)
   return __cmp;
 return __x._M_cur <=> __y._M_cur;
      }
# 371 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      [[__nodiscard__]]
      friend difference_type
      operator-(const _Self& __x, const _Self& __y) noexcept
      {
 return difference_type(_S_buffer_size())
   * (__x._M_node - __y._M_node - bool(__x._M_node))
   + (__x._M_cur - __x._M_first)
   + (__y._M_last - __y._M_cur);
      }





      template<typename _RefR, typename _PtrR>
 [[__nodiscard__]]
 friend difference_type
 operator-(const _Self& __x,
    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
 noexcept
 {
   return difference_type(_S_buffer_size())
     * (__x._M_node - __y._M_node - bool(__x._M_node))
     + (__x._M_cur - __x._M_first)
     + (__y._M_last - __y._M_cur);
 }

      [[__nodiscard__]]
      friend _Self
      operator+(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp += __n;
 return __tmp;
      }

      [[__nodiscard__]]
      friend _Self
      operator-(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp -= __n;
 return __tmp;
      }

      [[__nodiscard__]]
      friend _Self
      operator+(difference_type __n, const _Self& __x) noexcept
      { return __x + __n; }
    };
# 432 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
 }
    }
# 639 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }
# 790 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class deque : protected _Deque_base<_Tp, _Alloc>
    {
# 803 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 867 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      explicit
      deque(const allocator_type& __a)
      : _Base(__a, 0) { }
# 880 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 893 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 920 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 936 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      deque(deque&&) = default;


      deque(const deque& __x, const __type_identity_t<allocator_type>& __a)
      : _Base(__a, __x.size())
      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
        this->_M_impl._M_start,
        _M_get_Tp_allocator()); }


      deque(deque&& __x, const __type_identity_t<allocator_type>& __a)
      : deque(std::move(__x), __a, typename _Alloc_traits::is_always_equal{})
      { }

    private:
      deque(deque&& __x, const allocator_type& __a, true_type)
      : _Base(std::move(__x), __a)
      { }

      deque(deque&& __x, const allocator_type& __a, false_type)
      : _Base(std::move(__x), __a, __x.size())
      {
 if (__x.get_allocator() != __a && !__x.empty())
   {
     std::__uninitialized_move_a(__x.begin(), __x.end(),
     this->_M_impl._M_start,
     _M_get_Tp_allocator());
     __x.clear();
   }
      }

    public:
# 979 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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());
      }
# 1004 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
 }
# 1042 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      ~deque()
      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
# 1054 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      deque&
      operator=(const deque& __x);
# 1066 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1085 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1104 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 1121 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 1148 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      assign(initializer_list<value_type> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
# 1201 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      [[__nodiscard__]]
      allocator_type
      get_allocator() const noexcept
      { return _Base::get_allocator(); }






      [[__nodiscard__]]
      iterator
      begin() noexcept
      { return this->_M_impl._M_start; }





      [[__nodiscard__]]
      const_iterator
      begin() const noexcept
      { return this->_M_impl._M_start; }






      [[__nodiscard__]]
      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]]
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]]
      const_iterator
      cbegin() const noexcept
      { return this->_M_impl._M_start; }






      [[__nodiscard__]]
      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }




      [[__nodiscard__]]
      size_type
      size() const noexcept
      {
 size_type __sz = this->_M_impl._M_finish - this->_M_impl._M_start;
 if (__sz > max_size ())
   __builtin_unreachable ();
 return __sz;
      }


      [[__nodiscard__]]
      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 1354 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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));
      }
# 1376 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      resize(size_type __new_size, const value_type& __x)
# 1393 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 1429 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      [[__nodiscard__]]
      reference
      operator[](size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } while (false);
 return this->_M_impl._M_start[difference_type(__n)];
      }
# 1448 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      [[__nodiscard__]]
      const_reference
      operator[](size_type __n) const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(__n < this->size())) std::__glibcxx_assert_fail(); } 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:
# 1480 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1498 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      [[__nodiscard__]]
      reference
      front() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }





      [[__nodiscard__]]
      const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return *begin();
      }





      [[__nodiscard__]]
      reference
      back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      [[__nodiscard__]]
      const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 1567 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 1604 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 1640 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      pop_front() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } 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();
      }
# 1663 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      pop_back() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } 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();
      }
# 1688 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args);
# 1701 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1727 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return emplace(__position, std::move(__x)); }
# 1741 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1760 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
      }
# 1794 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
 }
# 1872 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }
# 1896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
# 1915 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      swap(deque& __x) noexcept
      {

 do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) std::__glibcxx_assert_fail(); } while (false);


 _M_impl._M_swap_data(__x._M_impl);
 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
      __x._M_get_Tp_allocator());
      }







      void
      clear() noexcept
      { _M_erase_at_end(begin()); }

    protected:
# 1965 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 1994 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
# 2016 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      _M_fill_initialize(const value_type& __value);



      void
      _M_default_initialize();
# 2047 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
   }
      }
# 2095 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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();
# 2134 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      template<typename _InputIterator, typename _Sentinel>
      void _M_range_prepend(_InputIterator __first, _Sentinel __last,
       size_type __n);


      template<typename _InputIterator, typename _Sentinel>
      void _M_range_append(_InputIterator __first, _Sentinel __last,
      size_type __n);


      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);






      iterator
      _M_insert_aux(iterator __pos, const value_type& __x)
      { return _M_emplace_aux(__pos, __x); }

      template<typename... _Args>
 iterator
 _M_emplace_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);
# 2280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
      void
      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
      {
 if (__nodes_to_add + 1 > this->_M_impl._M_map_size
     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
   _M_reallocate_map(__nodes_to_add, false);
      }

      void
      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
      {
 if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
           - this->_M_impl._M_map))
   _M_reallocate_map(__nodes_to_add, true);
      }

      void
      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);





      void
      _M_move_assign1(deque&& __x, true_type) noexcept
      {
 this->_M_impl._M_swap_data(__x._M_impl);
 __x.clear();
 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
      }




      void
      _M_move_assign1(deque&& __x, false_type)
      {
 if (_M_get_Tp_allocator() == __x._M_get_Tp_allocator())
   return _M_move_assign1(std::move(__x), true_type());

 constexpr bool __move_storage =
   _Alloc_traits::_S_propagate_on_move_assign();
 _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
      }



      template<typename... _Args>
      void
      _M_replace_map(_Args&&... __args)
      {

 deque __newobj(std::forward<_Args>(__args)...);

 clear();
 _M_deallocate_node(*begin()._M_node);
 _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
 this->_M_impl._M_map = nullptr;
 this->_M_impl._M_map_size = 0;

 this->_M_impl._M_swap_data(__newobj._M_impl);
      }


      void
      _M_move_assign2(deque&& __x, true_type)
      {

 auto __alloc = __x._M_get_Tp_allocator();


 _M_replace_map(std::move(__x));

 _M_get_Tp_allocator() = std::move(__alloc);
      }



      void
      _M_move_assign2(deque&& __x, false_type)
      {
 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
   {


     _M_replace_map(std::move(__x), __x.get_allocator());
   }
 else
   {


     _M_assign_aux(std::make_move_iterator(__x.begin()),
     std::make_move_iterator(__x.end()),
     std::random_access_iterator_tag());
     __x.clear();
   }
      }

    };


  template<typename _InputIterator, typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_ValT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    deque(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> deque<_ValT, _Allocator>;
# 2407 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    [[__nodiscard__]]
    inline bool
    operator==(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return __x.size() == __y.size()
      && std::equal(__x.begin(), __x.end(), __y.begin()); }
# 2426 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    [[nodiscard]]
    inline __detail::__synth3way_t<_Tp>
    operator<=>(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    {
      return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
          __y.begin(), __y.end(),
          __detail::__synth3way);
    }
# 2484 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    inline void
    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }
# 2497 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_deque.h" 3
  template<class _Tp>
    struct __is_bitwise_relocatable<std::deque<_Tp>>
    : true_type { };



}
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/deque" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/deque.tcc" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template <typename _Tp, typename _Alloc>
    void
    deque<_Tp, _Alloc>::
    _M_default_initialize()
    {
      _Map_pointer __cur;
      try
 {
   for (__cur = this->_M_impl._M_start._M_node;
        __cur < this->_M_impl._M_finish._M_node;
        ++__cur)
     std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
        _M_get_Tp_allocator());
   std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
      this->_M_impl._M_finish._M_cur,
      _M_get_Tp_allocator());
 }
      catch(...)
 {
   std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
   _M_get_Tp_allocator());
   throw;
 }
    }


  template <typename _Tp, typename _Alloc>
    deque<_Tp, _Alloc>&
    deque<_Tp, _Alloc>::
    operator=(const deque& __x)
    {
      if (std::__addressof(__x) != this)
 {

   if (_Alloc_traits::_S_propagate_on_copy_assign())
     {
       if (!_Alloc_traits::_S_always_equal()
    && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
  {


    _M_replace_map(__x, __x.get_allocator());
    std::__alloc_on_copy(_M_get_Tp_allocator(),
           __x._M_get_Tp_allocator());
    return *this;
  }
       std::__alloc_on_copy(_M_get_Tp_allocator(),
       __x._M_get_Tp_allocator());
     }

   const size_type __len = size();
   if (__len >= __x.size())
     _M_erase_at_end(std::copy(__x.begin(), __x.end(),
          this->_M_impl._M_start));
   else
     {
       const_iterator __mid = __x.begin() + difference_type(__len);
       std::copy(__x.begin(), __mid, this->_M_impl._M_start);
       _M_range_insert_aux(this->_M_impl._M_finish, __mid, __x.end(),
      std::random_access_iterator_tag());
     }
 }
      return *this;
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>

      typename deque<_Tp, _Alloc>::reference



      deque<_Tp, _Alloc>::
      emplace_front(_Args&&... __args)
      {
 if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
   {
     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_start._M_cur - 1,
         std::forward<_Args>(__args)...);
     --this->_M_impl._M_start._M_cur;
   }
 else
   _M_push_front_aux(std::forward<_Args>(__args)...);

 return front();

      }

  template<typename _Tp, typename _Alloc>
    template<typename... _Args>

      typename deque<_Tp, _Alloc>::reference



      deque<_Tp, _Alloc>::
      emplace_back(_Args&&... __args)
      {
 if (this->_M_impl._M_finish._M_cur
     != this->_M_impl._M_finish._M_last - 1)
   {
     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_finish._M_cur,
         std::forward<_Args>(__args)...);
     ++this->_M_impl._M_finish._M_cur;
   }
 else
   _M_push_back_aux(std::forward<_Args>(__args)...);

 return back();

      }



  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      typename deque<_Tp, _Alloc>::iterator
      deque<_Tp, _Alloc>::
      emplace(const_iterator __position, _Args&&... __args)
      {
 if (__position._M_cur == this->_M_impl._M_start._M_cur)
   {
     emplace_front(std::forward<_Args>(__args)...);
     return this->_M_impl._M_start;
   }
 else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
   {
     emplace_back(std::forward<_Args>(__args)...);
     iterator __tmp = this->_M_impl._M_finish;
     --__tmp;
     return __tmp;
   }
 else
   return _M_emplace_aux(__position._M_const_cast(),
    std::forward<_Args>(__args)...);
      }


  template <typename _Tp, typename _Alloc>
    typename deque<_Tp, _Alloc>::iterator
    deque<_Tp, _Alloc>::

    insert(const_iterator __position, const value_type& __x)



    {
      if (__position._M_cur == this->_M_impl._M_start._M_cur)
 {
   push_front(__x);
   return this->_M_impl._M_start;
 }
      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
 {
   push_back(__x);
   iterator __tmp = this->_M_impl._M_finish;
   --__tmp;
   return __tmp;
 }
      else
 return _M_insert_aux(__position._M_const_cast(), __x);
   }

  template <typename _Tp, typename _Alloc>
    typename deque<_Tp, _Alloc>::iterator
    deque<_Tp, _Alloc>::
    _M_erase(iterator __position)
    {
      iterator __next = __position;
      ++__next;
      const difference_type __index = __position - begin();
      if (static_cast<size_type>(__index) < (size() >> 1))
 {
   if (__position != begin())
     std::move_backward(begin(), __position, __next);
   pop_front();
 }
      else
 {
   if (__next != end())
     std::move(__next, end(), __position);
   pop_back();
 }
      return begin() + __index;
    }

  template <typename _Tp, typename _Alloc>
    typename deque<_Tp, _Alloc>::iterator
    deque<_Tp, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first == __last)
 return __first;
      else if (__first == begin() && __last == end())
 {
   clear();
   return end();
 }
      else
 {
   const difference_type __n = __last - __first;
   const difference_type __elems_before = __first - begin();
   if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
     {
       if (__first != begin())
  std::move_backward(begin(), __first, __last);
       _M_erase_at_begin(begin() + __n);
     }
   else
     {
       if (__last != end())
  std::move(__last, end(), __first);
       _M_erase_at_end(end() - __n);
     }
   return begin() + __elems_before;
 }
    }

  template <typename _Tp, class _Alloc>
    template <typename _InputIterator>
      void
      deque<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 iterator __cur = begin();
 for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   _M_range_insert_aux(end(), __first, __last,
         std::__iterator_category(__first));
      }

  template <typename _Tp, typename _Alloc>
    void
    deque<_Tp, _Alloc>::
    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
    {
      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
 {
   iterator __new_start = _M_reserve_elements_at_front(__n);
   try
     {
       std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
       __x, _M_get_Tp_allocator());
       this->_M_impl._M_start = __new_start;
     }
   catch(...)
     {
       _M_destroy_nodes(__new_start._M_node,
          this->_M_impl._M_start._M_node);
       throw;
     }
 }
      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
 {
   iterator __new_finish = _M_reserve_elements_at_back(__n);
   try
     {
       std::__uninitialized_fill_a(this->_M_impl._M_finish,
       __new_finish, __x,
       _M_get_Tp_allocator());
       this->_M_impl._M_finish = __new_finish;
     }
   catch(...)
     {
       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
          __new_finish._M_node + 1);
       throw;
     }
 }
      else
 _M_insert_aux(__pos, __n, __x);
    }


  template <typename _Tp, typename _Alloc>
    void
    deque<_Tp, _Alloc>::
    _M_default_append(size_type __n)
    {
      if (__n)
 {
   iterator __new_finish = _M_reserve_elements_at_back(__n);
   try
     {
       std::__uninitialized_default_a(this->_M_impl._M_finish,
          __new_finish,
          _M_get_Tp_allocator());
       this->_M_impl._M_finish = __new_finish;
     }
   catch(...)
     {
       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
          __new_finish._M_node + 1);
       throw;
     }
 }
    }

  template <typename _Tp, typename _Alloc>
    bool
    deque<_Tp, _Alloc>::
    _M_shrink_to_fit()
    {
      const difference_type __front_capacity
 = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
      if (__front_capacity == 0)
 return false;

      const difference_type __back_capacity
 = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
      if (__front_capacity + __back_capacity < _S_buffer_size())
 return false;

      return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
    }


  template <typename _Tp, typename _Alloc>
    void
    deque<_Tp, _Alloc>::
    _M_fill_initialize(const value_type& __value)
    {
      _Map_pointer __cur;
      try
 {
   for (__cur = this->_M_impl._M_start._M_node;
        __cur < this->_M_impl._M_finish._M_node;
        ++__cur)
     std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
     __value, _M_get_Tp_allocator());
   std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
          this->_M_impl._M_finish._M_cur,
          __value, _M_get_Tp_allocator());
 }
      catch(...)
 {
   std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
   _M_get_Tp_allocator());
   throw;
 }
    }

  template <typename _Tp, typename _Alloc>
    template <typename _InputIterator>
      void
      deque<_Tp, _Alloc>::
      _M_range_initialize(_InputIterator __first, _InputIterator __last,
     std::input_iterator_tag)
      {
 this->_M_initialize_map(0);
 try
   {
     for (; __first != __last; ++__first)

       emplace_back(*__first);



   }
 catch(...)
   {
     clear();
     throw;
   }
      }

  template <typename _Tp, typename _Alloc>
    template <typename _ForwardIterator>
      void
      deque<_Tp, _Alloc>::
      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
     std::forward_iterator_tag)
      {
 const size_type __n = std::distance(__first, __last);
 this->_M_initialize_map(_S_check_init_len(__n, _M_get_Tp_allocator()));

 _Map_pointer __cur_node;
 try
   {
     for (__cur_node = this->_M_impl._M_start._M_node;
   __cur_node < this->_M_impl._M_finish._M_node;
   ++__cur_node)
       {
  if (__n < _S_buffer_size())
    __builtin_unreachable();

  _ForwardIterator __mid = __first;
  std::advance(__mid, _S_buffer_size());
  std::__uninitialized_copy_a(__first, __mid, *__cur_node,
         _M_get_Tp_allocator());
  __first = __mid;
       }
     std::__uninitialized_copy_a(__first, __last,
     this->_M_impl._M_finish._M_first,
     _M_get_Tp_allocator());
   }
 catch(...)
   {
     std::_Destroy(this->_M_impl._M_start,
     iterator(*__cur_node, __cur_node),
     _M_get_Tp_allocator());
     throw;
   }
      }


  template<typename _Tp, typename _Alloc>

    template<typename... _Args>
      void
      deque<_Tp, _Alloc>::
      _M_push_back_aux(_Args&&... __args)





      {
 if (size() == max_size())
   __throw_length_error(
       ("cannot create std::deque larger than max_size()"));

 _M_reserve_map_at_back();
 *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
 try
   {

     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_finish._M_cur,
         std::forward<_Args>(__args)...);



     this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
      + 1);
     this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
   }
 catch(...)
   {
     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
     throw;
   }
      }


  template<typename _Tp, typename _Alloc>

    template<typename... _Args>
      void
      deque<_Tp, _Alloc>::
      _M_push_front_aux(_Args&&... __args)





      {
 if (size() == max_size())
   __throw_length_error(
       ("cannot create std::deque larger than max_size()"));

 _M_reserve_map_at_front();
 *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
 try
   {
     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
            - 1);
     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;

     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_start._M_cur,
         std::forward<_Args>(__args)...);



   }
 catch(...)
   {
     ++this->_M_impl._M_start;
     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
     throw;
   }
      }


  template <typename _Tp, typename _Alloc>
    void deque<_Tp, _Alloc>::
    _M_pop_back_aux()
    {
      _M_deallocate_node(this->_M_impl._M_finish._M_first);
      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
      _Alloc_traits::destroy(_M_get_Tp_allocator(),
        this->_M_impl._M_finish._M_cur);
    }






  template <typename _Tp, typename _Alloc>
    void deque<_Tp, _Alloc>::
    _M_pop_front_aux()
    {
      _Alloc_traits::destroy(_M_get_Tp_allocator(),
        this->_M_impl._M_start._M_cur);
      _M_deallocate_node(this->_M_impl._M_start._M_first);
      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
    }

  template <typename _Tp, typename _Alloc>
    template <typename _InputIterator, typename _Sentinel>
      void
      deque<_Tp, _Alloc>::
      _M_range_prepend(_InputIterator __first, _Sentinel __last,
        size_type __n)
      {
  iterator __new_start = _M_reserve_elements_at_front(__n);
  try
    {
      std::__uninitialized_copy_a(std::move(__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;
    }
      }

  template <typename _Tp, typename _Alloc>
    template <typename _InputIterator, typename _Sentinel>
      void
      deque<_Tp, _Alloc>::
      _M_range_append(_InputIterator __first, _Sentinel __last,
        size_type __n)
     {
       iterator __new_finish = _M_reserve_elements_at_back(__n);
       try
 {
   std::__uninitialized_copy_a(std::move(__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;
 }
     }

  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 (__builtin_expect(__n == 0, 0))
   return;

 if (__pos._M_cur == this->_M_impl._M_start._M_cur)
   _M_range_prepend(__first, __last, __n);
 else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
   _M_range_append(__first, __last, __n);
 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_emplace_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;
     }
 }
      }
# 1027 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/deque.tcc" 3
   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;

   const size_t __bufsz = __deque_buf_size(sizeof(_Tp));
   if (__new_map_size > ((max_size() + __bufsz - 1) / __bufsz) * 2)
     __builtin_unreachable();

   _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
   __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
    + (__add_at_front ? __nodes_to_add : 0);
   std::copy(this->_M_impl._M_start._M_node,
      this->_M_impl._M_finish._M_node + 1,
      __new_nstart);
   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);

   this->_M_impl._M_map = __new_map;
   this->_M_impl._M_map_size = __new_map_size;
 }

      this->_M_impl._M_start._M_set_node(__new_nstart);
      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
    }





  template<typename _Tp, typename _VTp>
    void
    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __last,
       const _VTp& __value)
    {
      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
      if (__first._M_node != __last._M_node)
 {
   std::__fill_a1(__first._M_cur, __first._M_last, __value);

   for (typename _Iter::_Map_pointer __node = __first._M_node + 1;
        __node < __last._M_node; ++__node)
     std::__fill_a1(*__node, *__node + _Iter::_S_buffer_size(), __value);

   std::__fill_a1(__last._M_first, __last._M_cur, __value);
 }
      else
 std::__fill_a1(__first._M_cur, __last._M_cur, __value);
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_dit(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
      std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
      _OI __result)
    {
      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
      if (__first._M_node != __last._M_node)
 {
   __result
     = std::__copy_move_a1<_IsMove>(__first._M_cur, __first._M_last,
        __result);

   for (typename _Iter::_Map_pointer __node = __first._M_node + 1;
        __node != __last._M_node; ++__node)
     __result
       = std::__copy_move_a1<_IsMove>(*__node,
          *__node + _Iter::_S_buffer_size(),
          __result);

   return std::__copy_move_a1<_IsMove>(__last._M_first, __last._M_cur,
           __result);
 }

      return std::__copy_move_a1<_IsMove>(__first._M_cur, __last._M_cur,
       __result);
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
     std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
     _OI __result)
    { return __copy_move_dit<_IsMove>(__first, __last, __result); }

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr> __first,
     std::_Deque_iterator<_ITp, _IRef, _IPtr> __last,
     std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result)
    { return __copy_move_dit<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_a1(_II __first, _II __last,
     std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
    {
      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
      typedef typename _Iter::difference_type difference_type;

      difference_type __len = __last - __first;
      while (__len > 0)
 {
   const difference_type __clen
     = std::min(__len, __result._M_last - __result._M_cur);
   std::__copy_move_a1<_IsMove>(__first, __first + __clen,
           __result._M_cur);

   __first += __clen;
   __result += __clen;
   __len -= __clen;
 }

      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_move_a2(
 istreambuf_iterator<_CharT, char_traits<_CharT> > __first,
 istreambuf_iterator<_CharT, char_traits<_CharT> > __last,
 std::_Deque_iterator<_CharT, _CharT&, _CharT*> __result)
    {
      if (__first == __last)
 return __result;

      for (;;)
 {
   const std::ptrdiff_t __len = __result._M_last - __result._M_cur;
   const std::ptrdiff_t __nb
     = std::__copy_n_a(__first, __len, __result._M_cur, false)
     - __result._M_cur;
   __result += __nb;

   if (__nb != __len)
     break;
 }

      return __result;
    }

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_n_a(
      istreambuf_iterator<_CharT, char_traits<_CharT> > __it, _Size __size,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> __result,
      bool __strict)
    {
      if (__size == 0)
 return __result;

      do
 {
   const _Size __len
     = std::min<_Size>(__result._M_last - __result._M_cur, __size);
   std::__copy_n_a(__it, __len, __result._M_cur, __strict);
   __result += __len;
   __size -= __len;
 }
      while (__size != 0);
      return __result;
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_backward_dit(
  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
  std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
  _OI __result)
    {
      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
      if (__first._M_node != __last._M_node)
 {
   __result = std::__copy_move_backward_a1<_IsMove>(
  __last._M_first, __last._M_cur, __result);

   for (typename _Iter::_Map_pointer __node = __last._M_node - 1;
        __node != __first._M_node; --__node)
     __result = std::__copy_move_backward_a1<_IsMove>(
  *__node, *__node + _Iter::_S_buffer_size(), __result);

   return std::__copy_move_backward_a1<_IsMove>(
   __first._M_cur, __first._M_last, __result);
 }

      return std::__copy_move_backward_a1<_IsMove>(
  __first._M_cur, __last._M_cur, __result);
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_backward_a1(
  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
  std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
  _OI __result)
    { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); }

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_backward_a1(
  std::_Deque_iterator<_ITp, _IRef, _IPtr> __first,
  std::_Deque_iterator<_ITp, _IRef, _IPtr> __last,
  std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result)
    { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_backward_a1(_II __first, _II __last,
  std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
    {
      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
      typedef typename _Iter::difference_type difference_type;

      difference_type __len = __last - __first;
      while (__len > 0)
 {
   difference_type __rlen = __result._M_cur - __result._M_first;
   _Tp* __rend = __result._M_cur;
   if (!__rlen)
     {
       __rlen = _Iter::_S_buffer_size();
       __rend = *(__result._M_node - 1) + __rlen;
     }

   const difference_type __clen = std::min(__len, __rlen);
   std::__copy_move_backward_a1<_IsMove>(__last - __clen, __last, __rend);

   __last -= __clen;
   __result -= __clen;
   __len -= __clen;
 }

      return __result;
    }

  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    bool
    __equal_dit(
 const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __first1,
 const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __last1,
 _II __first2)
    {
      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
      if (__first1._M_node != __last1._M_node)
 {
   if (!std::__equal_aux1(__first1._M_cur, __first1._M_last, __first2))
     return false;

   __first2 += __first1._M_last - __first1._M_cur;
   for (typename _Iter::_Map_pointer __node = __first1._M_node + 1;
        __node != __last1._M_node;
        __first2 += _Iter::_S_buffer_size(), ++__node)
     if (!std::__equal_aux1(*__node, *__node + _Iter::_S_buffer_size(),
      __first2))
       return false;

   return std::__equal_aux1(__last1._M_first, __last1._M_cur, __first2);
 }

      return std::__equal_aux1(__first1._M_cur, __last1._M_cur, __first2);
    }

  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first1,
   std::_Deque_iterator<_Tp, _Ref, _Ptr> __last1,
   _II __first2)
    { return std::__equal_dit(__first1, __last1, __first2); }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2)
    { return std::__equal_dit(__first1, __last1, __first2); }

  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(_II __first1, _II __last1,
  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first2)
    {
      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
      typedef typename _Iter::difference_type difference_type;

      difference_type __len = __last1 - __first1;
      while (__len > 0)
 {
   const difference_type __clen
     = std::min(__len, __first2._M_last - __first2._M_cur);
   if (!std::__equal_aux1(__first1, __first1 + __clen, __first2._M_cur))
     return false;

   __first1 += __clen;
   __len -= __clen;
   __first2 += __clen;
 }

      return true;
    }

  template<typename _Tp1, typename _Ref, typename _Ptr, typename _Tp2>
    int
    __lex_cmp_dit(
 std::_Deque_iterator<_Tp1, _Ref, _Ptr> __first1,
 std::_Deque_iterator<_Tp1, _Ref, _Ptr> __last1,
 const _Tp2* __first2, const _Tp2* __last2)
    {

      const bool __simple =
 (__is_memcmp_ordered_with<_Tp1, _Tp2>::__value
  && __is_pointer(_Ptr)




  && !is_volatile_v<_Tp1> && !is_volatile_v<_Tp2>

  );
      typedef std::__lexicographical_compare<__simple> _Lc;




      while (__first1._M_node != __last1._M_node)
 {
   const ptrdiff_t __len1 = __first1._M_last - __first1._M_cur;
   const ptrdiff_t __len2 = __last2 - __first2;
   const ptrdiff_t __len = std::min(__len1, __len2);

   if (int __ret = _Lc::__3way(__first1._M_cur, __first1._M_last,
          __first2, __first2 + __len))
     return __ret;

   __first1 += __len;
   __first2 += __len;
 }
      return _Lc::__3way(__first1._M_cur, __last1._M_cur,
    __first2, __last2);
    }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2>
    inline bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
 _Tp2* __first2, _Tp2* __last2)
    { return std::__lex_cmp_dit(__first1, __last1, __first2, __last2) < 0; }

  template<typename _Tp1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    inline bool
    __lexicographical_compare_aux1(_Tp1* __first1, _Tp1* __last1,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __last2)
    { return std::__lex_cmp_dit(__first2, __last2, __first1, __last1) > 0; }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    inline bool
    __lexicographical_compare_aux1(
  std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
  std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
  std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2,
  std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __last2)
    {

      const bool __simple =
 (__is_memcmp_ordered_with<_Tp1, _Tp2>::__value
  && __is_pointer(_Ptr1) && __is_pointer(_Ptr2)




  && !is_volatile_v<_Tp1> && !is_volatile_v<_Tp2>

  );
      typedef std::__lexicographical_compare<__simple> _Lc;




      while (__first1 != __last1)
 {
   const ptrdiff_t __len2 = __first2._M_node == __last2._M_node
     ? __last2._M_cur - __first2._M_cur
     : __first2._M_last - __first2._M_cur;
   if (__len2 == 0)
     return false;
   const ptrdiff_t __len1 = __first1._M_node == __last1._M_node
     ? __last1._M_cur - __first1._M_cur
     : __first1._M_last - __first1._M_cur;
   const ptrdiff_t __len = std::min(__len1, __len2);
   if (int __ret = _Lc::__3way(__first1._M_cur, __first1._M_cur + __len,
          __first2._M_cur, __first2._M_cur + __len))
     return __ret < 0;

   __first1 += __len;
   __first2 += __len;
 }

      return __last2 != __first2;
    }


}
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/deque" 2 3






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/deque" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp>
      using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, typename _Alloc, typename _Predicate>
    inline typename deque<_Tp, _Alloc>::size_type
    erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      std::deque<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

  template<typename _Tp, typename _Alloc,
    typename _Up >
    inline typename deque<_Tp, _Alloc>::size_type
    erase(deque<_Tp, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      std::deque<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__iter_equals_val(__value));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

}
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stack" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 1 3
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 106 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
  template<typename _Tp, typename _Sequence = deque<_Tp> >
    class stack
    {
# 119 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      template<typename _Tp1, typename _Seq1>
 friend bool
 operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);

      template<typename _Tp1, typename _Seq1>
 friend bool
 operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);


      template<typename _Tp1, three_way_comparable _Seq1>
 friend compare_three_way_result_t<_Seq1>
 operator<=>(const stack<_Tp1, _Seq1>&, const stack<_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:

      _Sequence c;

    public:
# 168 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      template<typename _Seq = _Sequence, typename _Requires = typename
        enable_if<is_default_constructible<_Seq>::value>::type>
 stack()
 : c() { }

      explicit
      stack(const _Sequence& __c)
      : c(__c) { }

      explicit
      stack(_Sequence&& __c)
      : c(std::move(__c)) { }
# 209 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 explicit
 stack(const _Alloc& __a)
 : c(__a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 stack(const _Sequence& __c, const _Alloc& __a)
 : c(__c, __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 stack(_Sequence&& __c, const _Alloc& __a)
 : c(std::move(__c), __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 stack(const stack& __q, const _Alloc& __a)
 : c(__q.c, __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 stack(stack&& __q, const _Alloc& __a)
 : c(std::move(__q.c), __a) { }
# 242 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      [[__nodiscard__]] bool
      empty() const
      { return c.empty(); }


      [[__nodiscard__]]
      size_type
      size() const
      { return c.size(); }





      [[__nodiscard__]]
      reference
      top()
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return c.back();
      }





      [[__nodiscard__]]
      const_reference
      top() const
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 return c.back();
      }
# 285 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      void
      push(const value_type& __x)
      { c.push_back(__x); }


      void
      push(value_type&& __x)
      { c.push_back(std::move(__x)); }


      template<typename... _Args>
 decltype(auto)
 emplace(_Args&&... __args)
 { return c.emplace_back(std::forward<_Args>(__args)...); }
# 330 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
      void
      pop()
      {
 do { if (std::__is_constant_evaluated() && !bool(!this->empty())) std::__glibcxx_assert_fail(); } while (false);
 c.pop_back();
      }


      void
      swap(stack& __s)

      noexcept(__is_nothrow_swappable<_Sequence>::value)



      {
 using std::swap;
 swap(c, __s.c);
      }






    };


  template<typename _Container,
    typename = _RequireNotAllocator<_Container>>
    stack(_Container) -> stack<typename _Container::value_type, _Container>;

  template<typename _Container, typename _Allocator,
    typename = _RequireNotAllocator<_Container>>
    stack(_Container, _Allocator)
    -> stack<typename _Container::value_type, _Container>;
# 406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __x.c == __y.c; }
# 425 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_stack.h" 3
  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __x.c < __y.c; }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__x < __y); }


  template<typename _Tp, three_way_comparable _Seq>
    [[nodiscard]]
    inline compare_three_way_result_t<_Seq>
    operator<=>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __x.c <=> __y.c; }



  template<typename _Tp, typename _Seq>
    inline


    typename enable_if<__is_swappable<_Seq>::value>::type



    swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<typename _Tp, typename _Seq, typename _Alloc>
    struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
    : public uses_allocator<_Seq, _Alloc>::type { };



}
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stack" 2 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
namespace regex_constants
{
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  enum [[__gnu__::__flag_enum__]] syntax_option_type : unsigned int
  {
    _S_icase = 1 << 0,
    _S_nosubs = 1 << 1,
    _S_optimize = 1 << 2,
    _S_collate = 1 << 3,
    _S_ECMAScript = 1 << 4,
    _S_basic = 1 << 5,
    _S_extended = 1 << 6,
    _S_awk = 1 << 7,
    _S_grep = 1 << 8,
    _S_egrep = 1 << 9,
    _S_polynomial = 1 << 10,
    _S_multiline = 1 << 11
  };





  inline constexpr syntax_option_type icase = _S_icase;






  inline constexpr syntax_option_type nosubs = _S_nosubs;







  inline constexpr syntax_option_type optimize = _S_optimize;





  inline constexpr syntax_option_type collate = _S_collate;
# 120 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  inline constexpr syntax_option_type ECMAScript = _S_ECMAScript;
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  inline constexpr syntax_option_type basic = _S_basic;







  inline constexpr syntax_option_type extended = _S_extended;
# 147 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  inline constexpr syntax_option_type awk = _S_awk;







  inline constexpr syntax_option_type grep = _S_grep;







  inline constexpr syntax_option_type egrep = _S_egrep;
# 175 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  inline constexpr syntax_option_type multiline = _S_multiline;



  inline constexpr syntax_option_type __multiline = _S_multiline;







  inline constexpr syntax_option_type __polynomial = _S_polynomial;

  [[__nodiscard__]]
  constexpr syntax_option_type
  operator&(syntax_option_type __a, syntax_option_type __b) noexcept
  {
    return (syntax_option_type)(static_cast<unsigned int>(__a)
    & static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr syntax_option_type
  operator|(syntax_option_type __a, syntax_option_type __b) noexcept
  {
    return (syntax_option_type)(static_cast<unsigned int>(__a)
    | static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr syntax_option_type
  operator^(syntax_option_type __a, syntax_option_type __b) noexcept
  {
    return (syntax_option_type)(static_cast<unsigned int>(__a)
    ^ static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr syntax_option_type
  operator~(syntax_option_type __a) noexcept
  { return (syntax_option_type)(~static_cast<unsigned int>(__a)); }

  constexpr
  inline syntax_option_type&
  operator&=(syntax_option_type& __a, syntax_option_type __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline syntax_option_type&
  operator|=(syntax_option_type& __a, syntax_option_type __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline syntax_option_type&
  operator^=(syntax_option_type& __a, syntax_option_type __b) noexcept
  { return __a = __a ^ __b; }
# 253 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  enum match_flag_type : unsigned int
  {
    _S_default,
    _S_not_bol = 1 << 0,
    _S_not_eol = 1 << 1,
    _S_not_bow = 1 << 2,
    _S_not_eow = 1 << 3,
    _S_any = 1 << 4,
    _S_not_null = 1 << 5,
    _S_continuous = 1 << 6,
    _S_prev_avail = 1 << 7,
    _S_sed = 1 << 8,
    _S_no_copy = 1 << 9,
    _S_first_only = 1 << 10,
    _S_match_flag_last = 1 << 11
  };




  inline constexpr match_flag_type match_default = _S_default;






  inline constexpr match_flag_type match_not_bol = _S_not_bol;






  inline constexpr match_flag_type match_not_eol = _S_not_eol;





  inline constexpr match_flag_type match_not_bow = _S_not_bow;





  inline constexpr match_flag_type match_not_eow = _S_not_eow;





  inline constexpr match_flag_type match_any = _S_any;




  inline constexpr match_flag_type match_not_null = _S_not_null;




  inline constexpr match_flag_type match_continuous = _S_continuous;







  inline constexpr match_flag_type match_prev_avail = _S_prev_avail;
# 351 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_constants.h" 3
  inline constexpr match_flag_type format_default = _S_default;







  inline constexpr match_flag_type format_sed = _S_sed;






  inline constexpr match_flag_type format_no_copy = _S_no_copy;





  inline constexpr match_flag_type format_first_only = _S_first_only;

  [[__nodiscard__]]
  constexpr match_flag_type
  operator&(match_flag_type __a, match_flag_type __b) noexcept
  {
    return (match_flag_type)(static_cast<unsigned int>(__a)
    & static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr match_flag_type
  operator|(match_flag_type __a, match_flag_type __b) noexcept
  {
    return (match_flag_type)(static_cast<unsigned int>(__a)
    | static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr match_flag_type
  operator^(match_flag_type __a, match_flag_type __b) noexcept
  {
    return (match_flag_type)(static_cast<unsigned int>(__a)
    ^ static_cast<unsigned int>(__b));
  }

  [[__nodiscard__]]
  constexpr match_flag_type
  operator~(match_flag_type __a) noexcept
  { return (match_flag_type)(~static_cast<unsigned int>(__a)); }

  constexpr
  inline match_flag_type&
  operator&=(match_flag_type& __a, match_flag_type __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline match_flag_type&
  operator|=(match_flag_type& __a, match_flag_type __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline match_flag_type&
  operator^=(match_flag_type& __a, match_flag_type __b) noexcept
  { return __a = __a ^ __b; }


}



}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_error.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_error.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







namespace regex_constants
{





  enum error_type
    {
      _S_error_collate,
      _S_error_ctype,
      _S_error_escape,
      _S_error_backref,
      _S_error_brack,
      _S_error_paren,
      _S_error_brace,
      _S_error_badbrace,
      _S_error_range,
      _S_error_space,
      _S_error_badrepeat,
      _S_error_complexity,
      _S_error_stack,
      _S_null,
      _S_grammar
    };


  inline constexpr error_type error_collate(_S_error_collate);


  inline constexpr error_type error_ctype(_S_error_ctype);





  inline constexpr error_type error_escape(_S_error_escape);


  inline constexpr error_type error_backref(_S_error_backref);


  inline constexpr error_type error_brack(_S_error_brack);


  inline constexpr error_type error_paren(_S_error_paren);


  inline constexpr error_type error_brace(_S_error_brace);


  inline constexpr error_type error_badbrace(_S_error_badbrace);





  inline constexpr error_type error_range(_S_error_range);





  inline constexpr error_type error_space(_S_error_space);




  inline constexpr error_type error_badrepeat(_S_error_badrepeat);





  inline constexpr error_type error_complexity(_S_error_complexity);





  inline constexpr error_type error_stack(_S_error_stack);


}
# 137 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_error.h" 3
  class regex_error : public std::runtime_error
  {
    using error_type = regex_constants::error_type;

    error_type _M_code;

  public:





    explicit
    regex_error(error_type __ecode);

    virtual ~regex_error() throw();






    regex_constants::error_type
    code() const noexcept
    { return _M_code; }

  private:

    regex_error(error_type __ecode, const char* __what)
    : std::runtime_error(__what), _M_code(__ecode)
    { }

    [[__noreturn__]]
    friend void
    __throw_regex_error(error_type __ecode __attribute__((__unused__)),
   const char* __what __attribute__((__unused__)))
    { (throw (regex_error(__ecode, __what))); }

  };



  [[__noreturn__]]
  void
  __throw_regex_error(regex_constants::error_type __ecode);

  [[__noreturn__]]
  inline void
  __throw_regex_error(regex_constants::error_type __ecode, const char* __what);






}
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{






  typedef long _StateIdT;
  inline constexpr _StateIdT _S_invalid_state_id = -1;

  template<typename _CharT>
    using _Matcher = std::function<bool (_CharT)>;



  enum _Opcode : int
  {
      _S_opcode_unknown,
      _S_opcode_alternative,
      _S_opcode_repeat,
      _S_opcode_backref,
      _S_opcode_line_begin_assertion,
      _S_opcode_line_end_assertion,
      _S_opcode_word_boundary,
      _S_opcode_subexpr_lookahead,
      _S_opcode_subexpr_begin,
      _S_opcode_subexpr_end,
      _S_opcode_dummy,
      _S_opcode_match,
      _S_opcode_accept,
  };

  struct _State_base
  {
  protected:
    _Opcode _M_opcode;

  public:
    _StateIdT _M_next;
    union
    {
      size_t _M_subexpr;
      size_t _M_backref_index;
      struct
      {


 _StateIdT _M_alt;


 bool _M_neg;
      };

      __gnu_cxx::__aligned_membuf<_Matcher<char>> _M_matcher_storage;
    };

  protected:
    explicit _State_base(_Opcode __opcode) noexcept
    : _M_opcode(__opcode), _M_next(_S_invalid_state_id)
    { }

  public:
    bool
    _M_has_alt() const noexcept
    {
      return _M_opcode == _S_opcode_alternative
 || _M_opcode == _S_opcode_repeat
 || _M_opcode == _S_opcode_subexpr_lookahead;
    }
# 122 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.h" 3
  };

  template<typename _Char_type>
    struct _State : _State_base
    {
      typedef _Matcher<_Char_type> _MatcherT;
      static_assert(sizeof(_MatcherT) == sizeof(_Matcher<char>),
      "std::function<bool(T)> has the same size as "
      "std::function<bool(char)>");
      static_assert(alignof(_MatcherT) == alignof(_Matcher<char>),
      "std::function<bool(T)> has the same alignment as "
      "std::function<bool(char)>");

      explicit
      _State(_Opcode __opcode) noexcept : _State_base(__opcode)
      {
 if (_M_opcode() == _S_opcode_match)
   new (this->_M_matcher_storage._M_addr()) _MatcherT();
      }

      _State(const _State& __rhs) : _State_base(__rhs)
      {
 if (__rhs._M_opcode() == _S_opcode_match)
   new (this->_M_matcher_storage._M_addr())
     _MatcherT(__rhs._M_get_matcher());
      }

      _State(_State&& __rhs) noexcept : _State_base(__rhs)
      {
 if (__rhs._M_opcode() == _S_opcode_match)
   new (this->_M_matcher_storage._M_addr())
     _MatcherT(std::move(__rhs._M_get_matcher()));
      }

      _State&
      operator=(const _State&) = delete;

      ~_State()
      {
 if (_M_opcode() == _S_opcode_match)
   _M_get_matcher().~_MatcherT();
      }



      _Opcode
      _M_opcode() const noexcept
      { return _State_base::_M_opcode; }

      bool
      _M_matches(_Char_type __char) const
      { return _M_get_matcher()(__char); }

      _MatcherT&
      _M_get_matcher() noexcept
      { return *static_cast<_MatcherT*>(this->_M_matcher_storage._M_addr()); }

      const _MatcherT&
      _M_get_matcher() const noexcept
      {
 return *static_cast<const _MatcherT*>(
     this->_M_matcher_storage._M_addr());
      }
    };

  struct _NFA_base
  {
    typedef regex_constants::syntax_option_type _FlagT;

    explicit
    _NFA_base(_FlagT __f) noexcept
    : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0),
    _M_has_backref(false)
    { }

    _NFA_base(_NFA_base&&) = default;

  protected:
    ~_NFA_base() = default;

  public:
    _FlagT
    _M_options() const noexcept
    { return _M_flags; }

    _StateIdT
    _M_start() const noexcept
    { return _M_start_state; }

    size_t
    _M_sub_count() const noexcept
    { return _M_subexpr_count; }

    std::vector<size_t> _M_paren_stack;
    _FlagT _M_flags;
    _StateIdT _M_start_state;
    size_t _M_subexpr_count;
    bool _M_has_backref;
  };

  template<typename _TraitsT>
    struct _NFA
    : _NFA_base, std::vector<_State<typename _TraitsT::char_type>>
    {
      typedef typename _TraitsT::char_type _Char_type;
      typedef _State<_Char_type> _StateT;
      typedef _Matcher<_Char_type> _MatcherT;

      _NFA(const typename _TraitsT::locale_type& __loc, _FlagT __flags)
      : _NFA_base(__flags)
      { _M_traits.imbue(__loc); }


      _NFA(const _NFA&) = delete;
      _NFA(_NFA&&) = default;

      _StateIdT
      _M_insert_accept()
      {
 auto __ret = _M_insert_state(_StateT(_S_opcode_accept));
 return __ret;
      }

      _StateIdT
      _M_insert_alt(_StateIdT __next, _StateIdT __alt,
      bool __neg __attribute__((__unused__)))
      {
 _StateT __tmp(_S_opcode_alternative);


 __tmp._M_next = __next;
 __tmp._M_alt = __alt;
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_repeat(_StateIdT __next, _StateIdT __alt, bool __neg)
      {
 _StateT __tmp(_S_opcode_repeat);


 __tmp._M_next = __next;
 __tmp._M_alt = __alt;
 __tmp._M_neg = __neg;
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_matcher(_MatcherT __m)
      {
 _StateT __tmp(_S_opcode_match);
 __tmp._M_get_matcher() = std::move(__m);
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_subexpr_begin()
      {
 auto __id = this->_M_subexpr_count++;
 this->_M_paren_stack.push_back(__id);
 _StateT __tmp(_S_opcode_subexpr_begin);
 __tmp._M_subexpr = __id;
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_subexpr_end()
      {
 _StateT __tmp(_S_opcode_subexpr_end);
 __tmp._M_subexpr = this->_M_paren_stack.back();
 this->_M_paren_stack.pop_back();
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_backref(size_t __index);

      _StateIdT
      _M_insert_line_begin()
      { return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); }

      _StateIdT
      _M_insert_line_end()
      { return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); }

      _StateIdT
      _M_insert_word_bound(bool __neg)
      {
 _StateT __tmp(_S_opcode_word_boundary);
 __tmp._M_neg = __neg;
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_lookahead(_StateIdT __alt, bool __neg)
      {
 _StateT __tmp(_S_opcode_subexpr_lookahead);
 __tmp._M_alt = __alt;
 __tmp._M_neg = __neg;
 return _M_insert_state(std::move(__tmp));
      }

      _StateIdT
      _M_insert_dummy()
      { return _M_insert_state(_StateT(_S_opcode_dummy)); }

      _StateIdT
      _M_insert_state(_StateT __s)
      {
 this->push_back(std::move(__s));
 if (this->size() > 100000)
   __throw_regex_error(
     regex_constants::error_space,
     "Number of NFA states exceeds limit. Please use shorter regex "
     "string, or use smaller brace expression, or make "
     "_GLIBCXX_REGEX_STATE_LIMIT larger.");
 return this->size() - 1;
      }


      void
      _M_eliminate_dummy();





    public:
      _TraitsT _M_traits;
    };




  template<typename _TraitsT>
    class _StateSeq
    {
    public:
      typedef _NFA<_TraitsT> _RegexT;

    public:
      _StateSeq(_RegexT& __nfa, _StateIdT __s)
      : _M_nfa(__nfa), _M_start(__s), _M_end(__s)
      { }

      _StateSeq(_RegexT& __nfa, _StateIdT __s, _StateIdT __end)
      : _M_nfa(__nfa), _M_start(__s), _M_end(__end)
      { }


      void
      _M_append(_StateIdT __id)
      {
 _M_nfa[_M_end]._M_next = __id;
 _M_end = __id;
      }


      void
      _M_append(const _StateSeq& __s)
      {
 _M_nfa[_M_end]._M_next = __s._M_start;
 _M_end = __s._M_end;
      }


      _StateSeq
      _M_clone();

    public:
      _RegexT& _M_nfa;
      _StateIdT _M_start;
      _StateIdT _M_end;
    };


}


}

#pragma GCC diagnostic pop

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.tcc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
# 147 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.tcc" 3
  template<typename _TraitsT>
    _StateIdT
    _NFA<_TraitsT>::_M_insert_backref(size_t __index)
    {
      if (this->_M_flags & regex_constants::__polynomial)
 __throw_regex_error(regex_constants::error_complexity,
       "Unexpected back-reference in polynomial mode.");







      if (__index >= _M_subexpr_count)
 __throw_regex_error(
   regex_constants::error_backref,
   "Back-reference index exceeds current sub-expression count.");
      for (auto __it : this->_M_paren_stack)
 if (__index == __it)
   __throw_regex_error(
     regex_constants::error_backref,
     "Back-reference referred to an opened sub-expression.");
      this->_M_has_backref = true;
      _StateT __tmp(_S_opcode_backref);
      __tmp._M_backref_index = __index;
      return _M_insert_state(std::move(__tmp));
    }

  template<typename _TraitsT>
    void
    _NFA<_TraitsT>::_M_eliminate_dummy()
    {
      for (auto& __it : *this)
 {
   while (__it._M_next >= 0 && (*this)[__it._M_next]._M_opcode()
   == _S_opcode_dummy)
     __it._M_next = (*this)[__it._M_next]._M_next;
   if (__it._M_has_alt())
     while (__it._M_alt >= 0 && (*this)[__it._M_alt]._M_opcode()
     == _S_opcode_dummy)
       __it._M_alt = (*this)[__it._M_alt]._M_next;
 }
    }


  template<typename _TraitsT>
    _StateSeq<_TraitsT>
    _StateSeq<_TraitsT>::_M_clone()
    {
      std::map<_StateIdT, _StateIdT> __m;
      std::stack<_StateIdT, std::deque<_StateIdT>> __stack;
      __stack.push(_M_start);
      while (!__stack.empty())
 {
   auto __u = __stack.top();
   __stack.pop();
   auto __dup = _M_nfa[__u];

   auto __id = _M_nfa._M_insert_state(std::move(__dup));
   __m[__u] = __id;
   if (__dup._M_has_alt())
     if (__dup._M_alt != _S_invalid_state_id
  && __m.count(__dup._M_alt) == 0)
       __stack.push(__dup._M_alt);
   if (__u == _M_end)
     continue;
   if (__dup._M_next != _S_invalid_state_id
       && __m.count(__dup._M_next) == 0)
     __stack.push(__dup._M_next);
 }
      for (auto __it : __m)
 {
   auto __v = __it.second;
   auto& __ref = _M_nfa[__v];
   if (__ref._M_next != _S_invalid_state_id)
     __ref._M_next = __m.find(__ref._M_next)->second;
   if (__ref._M_has_alt() && __ref._M_alt != _S_invalid_state_id)
     __ref._M_alt = __m.find(__ref._M_alt)->second;
 }
      return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]);
    }
}


}
# 406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_automaton.h" 2 3
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.h" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{





  struct _ScannerBase
  {
  public:

    enum _TokenT : unsigned
    {
      _S_token_anychar,
      _S_token_ord_char,
      _S_token_oct_num,
      _S_token_hex_num,
      _S_token_backref,
      _S_token_subexpr_begin,
      _S_token_subexpr_no_group_begin,
      _S_token_subexpr_lookahead_begin,
      _S_token_subexpr_end,
      _S_token_bracket_begin,
      _S_token_bracket_neg_begin,
      _S_token_bracket_end,
      _S_token_interval_begin,
      _S_token_interval_end,
      _S_token_quoted_class,
      _S_token_char_class_name,
      _S_token_collsymbol,
      _S_token_equiv_class_name,
      _S_token_opt,
      _S_token_or,
      _S_token_closure0,
      _S_token_closure1,
      _S_token_line_begin,
      _S_token_line_end,
      _S_token_word_bound,
      _S_token_comma,
      _S_token_dup_count,
      _S_token_eof,
      _S_token_bracket_dash,
      _S_token_unknown = -1u
    };

  protected:
    typedef regex_constants::syntax_option_type _FlagT;

    enum _StateT
    {
      _S_state_normal,
      _S_state_in_brace,
      _S_state_in_bracket,
    };

  protected:
    _ScannerBase(_FlagT __flags)
    : _M_state(_S_state_normal),
    _M_flags(__flags),
    _M_escape_tbl(_M_is_ecma()
    ? _M_ecma_escape_tbl
    : _M_awk_escape_tbl),
    _M_spec_char(_M_is_ecma()
   ? _M_ecma_spec_char
   : _M_flags & regex_constants::basic
   ? _M_basic_spec_char
   : _M_flags & regex_constants::extended
   ? _M_extended_spec_char
   : _M_flags & regex_constants::grep
   ? ".[\\*^$\n"
   : _M_flags & regex_constants::egrep
   ? ".[\\()*+?{|^$\n"
   : _M_flags & regex_constants::awk
   ? _M_extended_spec_char
   : nullptr),
    _M_at_bracket_start(false)
    { do { if (std::__is_constant_evaluated() && !bool(_M_spec_char)) std::__glibcxx_assert_fail(); } while (false); }

  protected:
    const char*
    _M_find_escape(char __c)
    {
      auto __it = _M_escape_tbl;
      for (; __it->first != '\0'; ++__it)
 if (__it->first == __c)
   return &__it->second;
      return nullptr;
    }

    bool
    _M_is_ecma() const
    { return _M_flags & regex_constants::ECMAScript; }

    bool
    _M_is_basic() const
    { return _M_flags & (regex_constants::basic | regex_constants::grep); }

    bool
    _M_is_extended() const
    {
      return _M_flags & (regex_constants::extended
    | regex_constants::egrep
    | regex_constants::awk);
    }

    bool
    _M_is_grep() const
    { return _M_flags & (regex_constants::grep | regex_constants::egrep); }

    bool
    _M_is_awk() const
    { return _M_flags & regex_constants::awk; }

  protected:

    const std::pair<char, _TokenT> _M_token_tbl[9] =
      {
 {'^', _S_token_line_begin},
 {'$', _S_token_line_end},
 {'.', _S_token_anychar},
 {'*', _S_token_closure0},
 {'+', _S_token_closure1},
 {'?', _S_token_opt},
 {'|', _S_token_or},
 {'\n', _S_token_or},
 {'\0', _S_token_or},
      };
    const std::pair<char, char> _M_ecma_escape_tbl[8] =
      {
 {'0', '\0'},
 {'b', '\b'},
 {'f', '\f'},
 {'n', '\n'},
 {'r', '\r'},
 {'t', '\t'},
 {'v', '\v'},
 {'\0', '\0'},
      };
    const std::pair<char, char> _M_awk_escape_tbl[11] =
      {
 {'"', '"'},
 {'/', '/'},
 {'\\', '\\'},
 {'a', '\a'},
 {'b', '\b'},
 {'f', '\f'},
 {'n', '\n'},
 {'r', '\r'},
 {'t', '\t'},
 {'v', '\v'},
 {'\0', '\0'},
      };
    const char* _M_ecma_spec_char = "^$\\.*+?()[]{}|";
    const char* _M_basic_spec_char = ".[\\*^$";
    const char* _M_extended_spec_char = ".[\\()*+?{|^$";

    _StateT _M_state;
    _FlagT _M_flags;
    _TokenT _M_token;
    const std::pair<char, char>* _M_escape_tbl;
    const char* _M_spec_char;
    bool _M_at_bracket_start;
  };
# 209 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.h" 3
  template<typename _CharT>
    class _Scanner
    : public _ScannerBase
    {
    public:
      typedef std::basic_string<_CharT> _StringT;
      typedef regex_constants::syntax_option_type _FlagT;
      typedef const std::ctype<_CharT> _CtypeT;

      _Scanner(const _CharT* __begin, const _CharT* __end,
        _FlagT __flags, std::locale __loc);

      void
      _M_advance();

      _TokenT
      _M_get_token() const noexcept
      { return _M_token; }

      const _StringT&
      _M_get_value() const noexcept
      { return _M_value; }






    private:
      void
      _M_scan_normal();

      void
      _M_scan_in_bracket();

      void
      _M_scan_in_brace();

      void
      _M_eat_escape_ecma();

      void
      _M_eat_escape_posix();

      void
      _M_eat_escape_awk();

      void
      _M_eat_class(char);

      const _CharT* _M_current;
      const _CharT* _M_end;
      _CtypeT& _M_ctype;
      _StringT _M_value;
      void (_Scanner::* _M_eat_escape)();
    };


}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.tcc" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
  template<typename _CharT>
    _Scanner<_CharT>::
    _Scanner(const _CharT* __begin, const _CharT* __end,
      _FlagT __flags, std::locale __loc)
    : _ScannerBase(__flags),
      _M_current(__begin), _M_end(__end),
      _M_ctype(std::use_facet<_CtypeT>(__loc)),
      _M_eat_escape(_M_is_ecma()
      ? &_Scanner::_M_eat_escape_ecma
      : &_Scanner::_M_eat_escape_posix)
    { _M_advance(); }

  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_advance()
    {
      if (_M_current == _M_end)
 {
   _M_token = _S_token_eof;
   return;
 }

      if (_M_state == _S_state_normal)
 _M_scan_normal();
      else if (_M_state == _S_state_in_bracket)
 _M_scan_in_bracket();
      else if (_M_state == _S_state_in_brace)
 _M_scan_in_brace();
      else
 {
   do { if (std::__is_constant_evaluated() && !bool(!"unexpected state while processing regex")) std::__glibcxx_assert_fail(); } while (false);
 }
    }




  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_scan_normal()
    {
      auto __c = *_M_current++;

      if (__builtin_strchr(_M_spec_char, _M_ctype.narrow(__c, ' ')) == nullptr)
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
   return;
 }
      if (__c == '\\')
 {
   if (_M_current == _M_end)
     __throw_regex_error(
       regex_constants::error_escape,
       "Invalid escape at end of regular expression");

   if (!_M_is_basic()
       || (*_M_current != '('
    && *_M_current != ')'
    && *_M_current != '{'))
     {
       (this->*_M_eat_escape)();
       return;
     }
   __c = *_M_current++;
 }
      if (__c == '(')
 {
   if (_M_is_ecma() && *_M_current == '?')
     {
       if (++_M_current == _M_end)
  __throw_regex_error(regex_constants::error_paren);

       if (*_M_current == ':')
  {
    ++_M_current;
    _M_token = _S_token_subexpr_no_group_begin;
  }
       else if (*_M_current == '=')
  {
    ++_M_current;
    _M_token = _S_token_subexpr_lookahead_begin;
    _M_value.assign(1, 'p');
  }
       else if (*_M_current == '!')
  {
    ++_M_current;
    _M_token = _S_token_subexpr_lookahead_begin;
    _M_value.assign(1, 'n');
  }
       else
  __throw_regex_error(regex_constants::error_paren,
        "Invalid '(?...)' zero-width assertion "
        "in regular expression");
     }
   else if (_M_flags & regex_constants::nosubs)
     _M_token = _S_token_subexpr_no_group_begin;
   else
     _M_token = _S_token_subexpr_begin;
 }
      else if (__c == ')')
 _M_token = _S_token_subexpr_end;
      else if (__c == '[')
 {
   _M_state = _S_state_in_bracket;
   _M_at_bracket_start = true;
   if (_M_current != _M_end && *_M_current == '^')
     {
       _M_token = _S_token_bracket_neg_begin;
       ++_M_current;
     }
   else
     _M_token = _S_token_bracket_begin;
 }
      else if (__c == '{')
 {
   _M_state = _S_state_in_brace;
   _M_token = _S_token_interval_begin;
 }
      else if (__builtin_expect(__c == _CharT(0), false))
 {
   if (!_M_is_ecma())
     __throw_regex_error(regex_constants::_S_null);
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
 }
      else if (__c != ']' && __c != '}')
 {
   auto __it = _M_token_tbl;
   auto __narrowc = _M_ctype.narrow(__c, '\0');
   for (; __it->first != '\0'; ++__it)
     if (__it->first == __narrowc)
       {
  _M_token = __it->second;
  return;
       }
   do { if (std::__is_constant_evaluated() && !bool(!"unexpected special character in regex")) std::__glibcxx_assert_fail(); } while (false);
 }
      else
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
 }
    }




  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_scan_in_bracket()
    {
      if (_M_current == _M_end)
 __throw_regex_error(regex_constants::error_brack);

      auto __c = *_M_current++;

      if (__c == '-')
 _M_token = _S_token_bracket_dash;
      else if (__c == '[')
 {
   if (_M_current == _M_end)
     __throw_regex_error(regex_constants::error_brack,
    "Incomplete '[[' character class in "
    "regular expression");

   if (*_M_current == '.')
     {
       _M_token = _S_token_collsymbol;
       _M_eat_class(*_M_current++);
     }
   else if (*_M_current == ':')
     {
       _M_token = _S_token_char_class_name;
       _M_eat_class(*_M_current++);
     }
   else if (*_M_current == '=')
     {
       _M_token = _S_token_equiv_class_name;
       _M_eat_class(*_M_current++);
     }
   else
     {
       _M_token = _S_token_ord_char;
       _M_value.assign(1, __c);
     }
 }



      else if (__c == ']' && (_M_is_ecma() || !_M_at_bracket_start))
 {
   _M_token = _S_token_bracket_end;
   _M_state = _S_state_normal;
 }

      else if (__c == '\\' && (_M_is_ecma() || _M_is_awk()))
 (this->*_M_eat_escape)();
      else
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
 }
      _M_at_bracket_start = false;
    }



  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_scan_in_brace()
    {
      if (_M_current == _M_end)
 __throw_regex_error(regex_constants::error_brace);

      auto __c = *_M_current++;

      if (_M_ctype.is(_CtypeT::digit, __c))
 {
   _M_token = _S_token_dup_count;
   _M_value.assign(1, __c);
   while (_M_current != _M_end
   && _M_ctype.is(_CtypeT::digit, *_M_current))
     _M_value += *_M_current++;
 }
      else if (__c == ',')
 _M_token = _S_token_comma;

      else if (_M_is_basic())
 {
   if (__c == '\\' && _M_current != _M_end && *_M_current == '}')
     {
       _M_state = _S_state_normal;
       _M_token = _S_token_interval_end;
       ++_M_current;
     }
   else
     __throw_regex_error(regex_constants::error_badbrace);
 }
      else if (__c == '}')
 {
   _M_state = _S_state_normal;
   _M_token = _S_token_interval_end;
 }
      else
 __throw_regex_error(regex_constants::error_badbrace);
    }

  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_eat_escape_ecma()
    {
      if (_M_current == _M_end)
 __throw_regex_error(regex_constants::error_escape);

      auto __c = *_M_current++;
      auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0'));

      if (__pos != nullptr && (__c != 'b' || _M_state == _S_state_in_bracket))
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, *__pos);
 }
      else if (__c == 'b')
 {
   _M_token = _S_token_word_bound;
   _M_value.assign(1, 'p');
 }
      else if (__c == 'B')
 {
   _M_token = _S_token_word_bound;
   _M_value.assign(1, 'n');
 }

      else if (__c == 'd'
        || __c == 'D'
        || __c == 's'
        || __c == 'S'
        || __c == 'w'
        || __c == 'W')
 {
   _M_token = _S_token_quoted_class;
   _M_value.assign(1, __c);
 }
      else if (__c == 'c')
 {
   if (_M_current == _M_end)
     __throw_regex_error(regex_constants::error_escape,
    "invalid '\\cX' control character in "
    "regular expression");
   _M_token = _S_token_ord_char;
   _M_value.assign(1, *_M_current++);
 }
      else if (__c == 'x' || __c == 'u')
 {
   _M_value.clear();
   const int __n = __c == 'x' ? 2 : 4;
   for (int __i = 0; __i < __n; __i++)
     {
       if (_M_current == _M_end
    || !_M_ctype.is(_CtypeT::xdigit, *_M_current))
  __throw_regex_error(regex_constants::error_escape,
        __n == 2
        ? "Invalid '\\xNN' control character in "
          "regular expression"
        : "Invalid '\\uNNNN' control character in "
          "regular expression");
       _M_value += *_M_current++;
     }
   _M_token = _S_token_hex_num;
 }

      else if (_M_ctype.is(_CtypeT::digit, __c))
 {
   _M_value.assign(1, __c);
   while (_M_current != _M_end
   && _M_ctype.is(_CtypeT::digit, *_M_current))
     _M_value += *_M_current++;
   _M_token = _S_token_backref;
 }
      else
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
 }
    }



  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_eat_escape_posix()
    {
      if (_M_current == _M_end)
 __throw_regex_error(regex_constants::error_escape);

      auto __c = *_M_current;
      auto __pos = __builtin_strchr(_M_spec_char, _M_ctype.narrow(__c, '\0'));

      if (__pos != nullptr && *__pos != '\0')
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, __c);
 }

      else if (_M_is_awk())
 {
   _M_eat_escape_awk();
   return;
 }
      else if (_M_is_basic() && _M_ctype.is(_CtypeT::digit, __c) && __c != '0')
 {
   _M_token = _S_token_backref;
   _M_value.assign(1, __c);
 }
      else
 {


   __throw_regex_error(regex_constants::error_escape);




 }
      ++_M_current;
    }

  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_eat_escape_awk()
    {
      auto __c = *_M_current++;
      auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0'));

      if (__pos != nullptr)
 {
   _M_token = _S_token_ord_char;
   _M_value.assign(1, *__pos);
 }

      else if (_M_ctype.is(_CtypeT::digit, __c)
        && __c != '8'
        && __c != '9')
 {
   _M_value.assign(1, __c);
   for (int __i = 0;
        __i < 2
        && _M_current != _M_end
        && _M_ctype.is(_CtypeT::digit, *_M_current)
        && *_M_current != '8'
        && *_M_current != '9';
        __i++)
     _M_value += *_M_current++;
   _M_token = _S_token_oct_num;
   return;
 }
      else
 __throw_regex_error(regex_constants::error_escape);
    }




  template<typename _CharT>
    void
    _Scanner<_CharT>::
    _M_eat_class(char __ch)
    {
      for (_M_value.clear(); _M_current != _M_end && *_M_current != __ch;)
 _M_value += *_M_current++;
      if (_M_current == _M_end
   || *_M_current++ != __ch
   || _M_current == _M_end
   || *_M_current++ != ']')
 {
   __throw_regex_error(__ch == ':' ? regex_constants::error_ctype
       : regex_constants::error_collate);
 }
    }
# 582 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.tcc" 3
}

}
# 272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_scanner.h" 2 3
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.h" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {

  template<typename>
    class regex_traits;

}

namespace __detail
{





  template<typename, bool, bool>
    struct _BracketMatcher;






  template<typename _TraitsT>
    class _Compiler
    {
    public:
      typedef typename _TraitsT::char_type _CharT;
      typedef _NFA<_TraitsT> _RegexT;
      typedef regex_constants::syntax_option_type _FlagT;

      _Compiler(const _CharT* __b, const _CharT* __e,
  const typename _TraitsT::locale_type& __traits, _FlagT __flags);

      shared_ptr<const _RegexT>
      _M_get_nfa() noexcept
      { return std::move(_M_nfa); }

    private:
      typedef _Scanner<_CharT> _ScannerT;
      typedef typename _TraitsT::string_type _StringT;
      typedef typename _ScannerT::_TokenT _TokenT;
      typedef _StateSeq<_TraitsT> _StateSeqT;
      typedef std::stack<_StateSeqT> _StackT;
      typedef std::ctype<_CharT> _CtypeT;


      bool
      _M_match_token(_TokenT __token);

      void
      _M_disjunction();

      void
      _M_alternative();

      bool
      _M_term();

      bool
      _M_assertion();

      bool
      _M_quantifier();

      bool
      _M_atom();

      bool
      _M_bracket_expression();

      template<bool __icase, bool __collate>
 void
 _M_insert_any_matcher_ecma();

      template<bool __icase, bool __collate>
 void
 _M_insert_any_matcher_posix();

      template<bool __icase, bool __collate>
 void
 _M_insert_char_matcher();

      template<bool __icase, bool __collate>
 void
 _M_insert_character_class_matcher();

      template<bool __icase, bool __collate>
 void
 _M_insert_bracket_matcher(bool __neg);


      struct _BracketState
      {
 enum class _Type : char { _None, _Char, _Class } _M_type = _Type::_None;
 _CharT _M_char = _CharT();

 void
 set(_CharT __c) noexcept { _M_type = _Type::_Char; _M_char = __c; }

 [[__nodiscard__]] _CharT
 get() const noexcept { return _M_char; }

 void
 reset(_Type __t = _Type::_None) noexcept { _M_type = __t; }

 explicit operator bool() const noexcept
 { return _M_type != _Type::_None; }


 [[__nodiscard__]] bool
 _M_is_char() const noexcept { return _M_type == _Type::_Char; }



 [[__nodiscard__]] bool
 _M_is_class() const noexcept { return _M_type == _Type::_Class; }
      };

      template<bool __icase, bool __collate>
 using _BracketMatcher
   = std::__detail::_BracketMatcher<_TraitsT, __icase, __collate>;




      template<bool __icase, bool __collate>
 bool
 _M_expression_term(_BracketState& __last_char,
      _BracketMatcher<__icase, __collate>& __matcher);

      int
      _M_cur_int_value(int __radix);

      bool
      _M_try_char();

      _StateSeqT
      _M_pop()
      {
 auto ret = _M_stack.top();
 _M_stack.pop();
 return ret;
      }

      static _FlagT
      _S_validate(_FlagT __f)
      {
 using namespace regex_constants;
 switch (__f & (ECMAScript|basic|extended|awk|grep|egrep))
   {
   case ECMAScript:
   case basic:
   case extended:
   case awk:
   case grep:
   case egrep:
     return __f;
   case _FlagT(0):
     return __f | ECMAScript;
   default:
     std::__throw_regex_error(_S_grammar, "conflicting grammar options");
   }
      }

      _FlagT _M_flags;
      _ScannerT _M_scanner;
      shared_ptr<_RegexT> _M_nfa;
      _StringT _M_value;
      _StackT _M_stack;
      const _TraitsT& _M_traits;
      const _CtypeT& _M_ctype;
    };


  template<typename _TraitsT, bool __icase, bool __collate>
    class _RegexTranslatorBase
    {
    public:
      typedef typename _TraitsT::char_type _CharT;
      typedef typename _TraitsT::string_type _StringT;
      typedef _StringT _StrTransT;

      explicit
      _RegexTranslatorBase(const _TraitsT& __traits)
      : _M_traits(__traits)
      { }

      _CharT
      _M_translate(_CharT __ch) const
      {
 if constexpr (__icase)
   return _M_traits.translate_nocase(__ch);
 else if constexpr (__collate)
   return _M_traits.translate(__ch);
 else
   return __ch;
      }

      _StrTransT
      _M_transform(_CharT __ch) const
      {
 _StrTransT __str(1, __ch);
 return _M_traits.transform(__str.begin(), __str.end());
      }




      bool
      _M_match_range(const _StrTransT& __first, const _StrTransT& __last,
       const _StrTransT& __s) const
      { return __first <= __s && __s <= __last; }

    protected:
      bool _M_in_range_icase(_CharT __first, _CharT __last, _CharT __ch) const
      {
 typedef std::ctype<_CharT> __ctype_type;
 const auto& __fctyp = use_facet<__ctype_type>(this->_M_traits.getloc());
 auto __lower = __fctyp.tolower(__ch);
 auto __upper = __fctyp.toupper(__ch);
 return (__first <= __lower && __lower <= __last)
   || (__first <= __upper && __upper <= __last);
      }

      const _TraitsT& _M_traits;
    };

  template<typename _TraitsT, bool __icase, bool __collate>
    class _RegexTranslator
    : public _RegexTranslatorBase<_TraitsT, __icase, __collate>
    {
    public:
      typedef _RegexTranslatorBase<_TraitsT, __icase, __collate> _Base;
      using _Base::_Base;
    };

  template<typename _TraitsT, bool __icase>
    class _RegexTranslator<_TraitsT, __icase, false>
    : public _RegexTranslatorBase<_TraitsT, __icase, false>
    {
    public:
      typedef _RegexTranslatorBase<_TraitsT, __icase, false> _Base;
      typedef typename _Base::_CharT _CharT;
      typedef _CharT _StrTransT;

      using _Base::_Base;

      _StrTransT
      _M_transform(_CharT __ch) const
      { return __ch; }

      bool
      _M_match_range(_CharT __first, _CharT __last, _CharT __ch) const
      {
 if constexpr (!__icase)
   return __first <= __ch && __ch <= __last;
 else
   return this->_M_in_range_icase(__first, __last, __ch);
      }
    };

  template<typename _CharType>
    class _RegexTranslator<std::regex_traits<_CharType>, true, true>
    : public _RegexTranslatorBase<std::regex_traits<_CharType>, true, true>
    {
    public:
      typedef _RegexTranslatorBase<std::regex_traits<_CharType>, true, true>
 _Base;
      typedef typename _Base::_CharT _CharT;
      typedef typename _Base::_StrTransT _StrTransT;

      using _Base::_Base;

      bool
      _M_match_range(const _StrTransT& __first, const _StrTransT& __last,
       const _StrTransT& __str) const
      {
 do { if (std::__is_constant_evaluated() && !bool(__first.size() == 1)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__last.size() == 1)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated() && !bool(__str.size() == 1)) std::__glibcxx_assert_fail(); } while (false);
 return this->_M_in_range_icase(__first[0], __last[0], __str[0]);
      }
    };

  template<typename _TraitsT>
    class _RegexTranslator<_TraitsT, false, false>
    {
    public:
      typedef typename _TraitsT::char_type _CharT;
      typedef _CharT _StrTransT;

      explicit
      _RegexTranslator(const _TraitsT&)
      { }

      _CharT
      _M_translate(_CharT __ch) const
      { return __ch; }

      _StrTransT
      _M_transform(_CharT __ch) const
      { return __ch; }

      bool
      _M_match_range(_CharT __first, _CharT __last, _CharT __ch) const
      { return __first <= __ch && __ch <= __last; }
    };

  template<typename _TraitsT, bool __is_ecma, bool __icase, bool __collate>
    struct _AnyMatcher;

  template<typename _TraitsT, bool __icase, bool __collate>
    struct _AnyMatcher<_TraitsT, false, __icase, __collate>
    {
      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
      typedef typename _TransT::_CharT _CharT;

      explicit
      _AnyMatcher(const _TraitsT& __traits)
      : _M_translator(__traits)
      { }

      bool
      operator()(_CharT __ch) const
      {
 static auto __nul = _M_translator._M_translate('\0');
 return _M_translator._M_translate(__ch) != __nul;
      }

      _TransT _M_translator;
    };

  template<typename _TraitsT, bool __icase, bool __collate>
    struct _AnyMatcher<_TraitsT, true, __icase, __collate>
    {
      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
      typedef typename _TransT::_CharT _CharT;

      explicit
      _AnyMatcher(const _TraitsT& __traits)
      : _M_translator(__traits)
      { }

      bool
      operator()(_CharT __ch) const
      { return _M_apply(__ch, typename is_same<_CharT, char>::type()); }

      bool
      _M_apply(_CharT __ch, true_type) const
      {
 auto __c = _M_translator._M_translate(__ch);
 auto __n = _M_translator._M_translate('\n');
 auto __r = _M_translator._M_translate('\r');
 return __c != __n && __c != __r;
      }

      bool
      _M_apply(_CharT __ch, false_type) const
      {
 auto __c = _M_translator._M_translate(__ch);
 auto __n = _M_translator._M_translate('\n');
 auto __r = _M_translator._M_translate('\r');
 auto __u2028 = _M_translator._M_translate(u'\u2028');
 auto __u2029 = _M_translator._M_translate(u'\u2029');
 return __c != __n && __c != __r && __c != __u2028 && __c != __u2029;
      }

      _TransT _M_translator;
    };

  template<typename _TraitsT, bool __icase, bool __collate>
    struct _CharMatcher
    {
      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
      typedef typename _TransT::_CharT _CharT;

      _CharMatcher(_CharT __ch, const _TraitsT& __traits)
      : _M_translator(__traits), _M_ch(_M_translator._M_translate(__ch))
      { }

      bool
      operator()(_CharT __ch) const
      { return _M_ch == _M_translator._M_translate(__ch); }

      _TransT _M_translator;
      _CharT _M_ch;
    };


  template<typename _TraitsT, bool __icase, bool __collate>
    struct _BracketMatcher
    {
    public:
      typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT;
      typedef typename _TransT::_CharT _CharT;
      typedef typename _TransT::_StrTransT _StrTransT;
      typedef typename _TraitsT::string_type _StringT;
      typedef typename _TraitsT::char_class_type _CharClassT;

    public:
      _BracketMatcher(bool __is_non_matching,
        const _TraitsT& __traits)
      : _M_class_set(0), _M_translator(__traits), _M_traits(__traits),
      _M_is_non_matching(__is_non_matching)
      { }

      bool
      operator()(_CharT __ch) const
      {
                                   ;
 return _M_apply(__ch, _UseCache());
      }

      void
      _M_add_char(_CharT __c)
      {
 _M_char_set.push_back(_M_translator._M_translate(__c));
                                         ;
      }

      _StringT
      _M_add_collate_element(const _StringT& __s)
      {
 auto __st = _M_traits.lookup_collatename(__s.data(),
       __s.data() + __s.size());
 if (__st.empty())
   __throw_regex_error(regex_constants::error_collate,
         "Invalid collate element.");
 _M_char_set.push_back(_M_translator._M_translate(__st[0]));
                                         ;
 return __st;
      }

      void
      _M_add_equivalence_class(const _StringT& __s)
      {
 auto __st = _M_traits.lookup_collatename(__s.data(),
       __s.data() + __s.size());
 if (__st.empty())
   __throw_regex_error(regex_constants::error_collate,
         "Invalid equivalence class.");
 __st = _M_traits.transform_primary(__st.data(),
        __st.data() + __st.size());
 _M_equiv_set.push_back(__st);
                                         ;
      }


      void
      _M_add_character_class(const _StringT& __s, bool __neg)
      {
 auto __mask = _M_traits.lookup_classname(__s.data(),
       __s.data() + __s.size(),
       __icase);
 if (__mask == 0)
   __throw_regex_error(regex_constants::error_collate,
         "Invalid character class.");
 if (!__neg)
   _M_class_set |= __mask;
 else
   _M_neg_class_set.push_back(__mask);
                                         ;
      }

      void
      _M_make_range(_CharT __l, _CharT __r)
      {
 if (__l > __r)
   __throw_regex_error(regex_constants::error_range,
         "Invalid range in bracket expression.");
 _M_range_set.push_back(make_pair(_M_translator._M_transform(__l),
      _M_translator._M_transform(__r)));
                                         ;
      }

      void
      _M_ready()
      {
 std::sort(_M_char_set.begin(), _M_char_set.end());
 auto __end = std::unique(_M_char_set.begin(), _M_char_set.end());
 _M_char_set.erase(__end, _M_char_set.end());
 _M_make_cache(_UseCache());
                                        ;
      }

    private:

      using _UseCache = typename std::is_same<_CharT, char>::type;

      static constexpr size_t
      _S_cache_size =
 1ul << (sizeof(_CharT) * 8 * int(_UseCache::value));

      struct _Dummy { };
      using _CacheT = std::__conditional_t<_UseCache::value,
        std::bitset<_S_cache_size>,
        _Dummy>;
      using _UnsignedCharT = typename std::make_unsigned<_CharT>::type;

      bool
      _M_apply(_CharT __ch, false_type) const;

      bool
      _M_apply(_CharT __ch, true_type) const
      { return _M_cache[static_cast<_UnsignedCharT>(__ch)]; }

      void
      _M_make_cache(true_type)
      {
 for (unsigned __i = 0; __i < _M_cache.size(); __i++)
   _M_cache[__i] = _M_apply(static_cast<_CharT>(__i), false_type());
      }

      void
      _M_make_cache(false_type)
      { }

    private:
      std::vector<_CharT> _M_char_set;
      std::vector<_StringT> _M_equiv_set;
      std::vector<pair<_StrTransT, _StrTransT>> _M_range_set;
      std::vector<_CharClassT> _M_neg_class_set;
      _CharClassT _M_class_set;
      _TransT _M_translator;
      const _TraitsT& _M_traits;
      bool _M_is_non_matching;
      _CacheT _M_cache;



    };


}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.tcc" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++20-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
  template<typename _TraitsT>
    _Compiler<_TraitsT>::
    _Compiler(const _CharT* __b, const _CharT* __e,
       const typename _TraitsT::locale_type& __loc, _FlagT __flags)
    : _M_flags(_S_validate(__flags)),
      _M_scanner(__b, __e, _M_flags, __loc),
      _M_nfa(make_shared<_RegexT>(__loc, _M_flags)),
      _M_traits(_M_nfa->_M_traits),
      _M_ctype(std::use_facet<_CtypeT>(__loc))
    {
      _StateSeqT __r(*_M_nfa, _M_nfa->_M_start());
      __r._M_append(_M_nfa->_M_insert_subexpr_begin());
      this->_M_disjunction();
      if (!_M_match_token(_ScannerT::_S_token_eof))
 __throw_regex_error(regex_constants::error_paren);
      __r._M_append(_M_pop());
      do { if (std::__is_constant_evaluated() && !bool(_M_stack.empty())) std::__glibcxx_assert_fail(); } while (false);
      __r._M_append(_M_nfa->_M_insert_subexpr_end());
      __r._M_append(_M_nfa->_M_insert_accept());
      _M_nfa->_M_eliminate_dummy();
    }

  template<typename _TraitsT>
    void
    _Compiler<_TraitsT>::
    _M_disjunction()
    {
      this->_M_alternative();
      while (_M_match_token(_ScannerT::_S_token_or))
 {
   _StateSeqT __alt1 = _M_pop();
   this->_M_alternative();
   _StateSeqT __alt2 = _M_pop();
   auto __end = _M_nfa->_M_insert_dummy();
   __alt1._M_append(__end);
   __alt2._M_append(__end);



   _M_stack.push(_StateSeqT(*_M_nfa,
       _M_nfa->_M_insert_alt(
         __alt2._M_start, __alt1._M_start, false),
       __end));
 }
    }

  template<typename _TraitsT>
    void
    _Compiler<_TraitsT>::
    _M_alternative()
    {
      if (this->_M_term())
 {
   _StateSeqT __re = _M_pop();
   this->_M_alternative();
   __re._M_append(_M_pop());
   _M_stack.push(__re);
 }
      else
 _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_dummy()));
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_term()
    {
      if (this->_M_assertion())
 return true;
      if (this->_M_atom())
 {
   while (this->_M_quantifier())
     ;
   return true;
 }
      return false;
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_assertion()
    {
      if (_M_match_token(_ScannerT::_S_token_line_begin))
 _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_begin()));
      else if (_M_match_token(_ScannerT::_S_token_line_end))
 _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_end()));
      else if (_M_match_token(_ScannerT::_S_token_word_bound))

 _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->
       _M_insert_word_bound(_M_value[0] == 'n')));
      else if (_M_match_token(_ScannerT::_S_token_subexpr_lookahead_begin))
 {
   auto __neg = _M_value[0] == 'n';
   this->_M_disjunction();
   if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
     __throw_regex_error(regex_constants::error_paren);
   auto __tmp = _M_pop();
   __tmp._M_append(_M_nfa->_M_insert_accept());
   _M_stack.push(
       _StateSeqT(
  *_M_nfa,
  _M_nfa->_M_insert_lookahead(__tmp._M_start, __neg)));
 }
      else
 return false;
      return true;
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_quantifier()
    {
      bool __neg = (_M_flags & regex_constants::ECMAScript);
      auto __init = [this, &__neg]()
 {
   if (_M_stack.empty())
     __throw_regex_error(regex_constants::error_badrepeat);
   __neg = __neg && _M_match_token(_ScannerT::_S_token_opt);
 };
      if (_M_match_token(_ScannerT::_S_token_closure0))
 {
   __init();
   auto __e = _M_pop();
   _StateSeqT __r(*_M_nfa,
    _M_nfa->_M_insert_repeat(_S_invalid_state_id,
        __e._M_start, __neg));
   __e._M_append(__r);
   _M_stack.push(__r);
 }
      else if (_M_match_token(_ScannerT::_S_token_closure1))
 {
   __init();
   auto __e = _M_pop();
   __e._M_append(_M_nfa->_M_insert_repeat(_S_invalid_state_id,
       __e._M_start, __neg));
   _M_stack.push(__e);
 }
      else if (_M_match_token(_ScannerT::_S_token_opt))
 {
   __init();
   auto __e = _M_pop();
   auto __end = _M_nfa->_M_insert_dummy();
   _StateSeqT __r(*_M_nfa,
    _M_nfa->_M_insert_repeat(_S_invalid_state_id,
        __e._M_start, __neg));
   __e._M_append(__end);
   __r._M_append(__end);
   _M_stack.push(__r);
 }
      else if (_M_match_token(_ScannerT::_S_token_interval_begin))
 {
   if (_M_stack.empty())
     __throw_regex_error(regex_constants::error_badrepeat);
   if (!_M_match_token(_ScannerT::_S_token_dup_count))
     __throw_regex_error(regex_constants::error_badbrace);
   _StateSeqT __r(_M_pop());
   _StateSeqT __e(*_M_nfa, _M_nfa->_M_insert_dummy());
   long __min_rep = _M_cur_int_value(10);
   bool __infi = false;
   long __n = 0;


   if (_M_match_token(_ScannerT::_S_token_comma))
     {
       if (_M_match_token(_ScannerT::_S_token_dup_count))
  __n = _M_cur_int_value(10) - __min_rep;
       else
  __infi = true;
     }
   if (!_M_match_token(_ScannerT::_S_token_interval_end))
     __throw_regex_error(regex_constants::error_brace);

   __neg = __neg && _M_match_token(_ScannerT::_S_token_opt);

   for (long __i = 0; __i < __min_rep; ++__i)
     __e._M_append(__r._M_clone());

   if (__infi)
     {
       auto __tmp = __r._M_clone();
       _StateSeqT __s(*_M_nfa,
        _M_nfa->_M_insert_repeat(_S_invalid_state_id,
            __tmp._M_start, __neg));
       __tmp._M_append(__s);
       __e._M_append(__s);
     }
   else
     {
       if (__n < 0)
  __throw_regex_error(regex_constants::error_badbrace);
       auto __end = _M_nfa->_M_insert_dummy();



       std::stack<_StateIdT> __stack;
       for (long __i = 0; __i < __n; ++__i)
  {
    auto __tmp = __r._M_clone();
    auto __alt = _M_nfa->_M_insert_repeat(__tmp._M_start,
       __end, __neg);
    __stack.push(__alt);
    __e._M_append(_StateSeqT(*_M_nfa, __alt, __tmp._M_end));
  }
       __e._M_append(__end);
       while (!__stack.empty())
  {
    auto& __tmp = (*_M_nfa)[__stack.top()];
    __stack.pop();
    std::swap(__tmp._M_next, __tmp._M_alt);
  }
     }
   _M_stack.push(__e);
 }
      else
 return false;
      return true;
    }
# 301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.tcc" 3
  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_atom()
    {
      if (_M_match_token(_ScannerT::_S_token_anychar))
 {
   if (!(_M_flags & regex_constants::ECMAScript))
     do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_posix<false, false>(); else _M_insert_any_matcher_posix<false, true>(); else if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_posix<true, false>(); else _M_insert_any_matcher_posix<true, true>(); } while (false);
   else
     do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_ecma<false, false>(); else _M_insert_any_matcher_ecma<false, true>(); else if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_ecma<true, false>(); else _M_insert_any_matcher_ecma<true, true>(); } while (false);
 }
      else if (_M_try_char())
 do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_char_matcher<false, false>(); else _M_insert_char_matcher<false, true>(); else if (!(_M_flags & regex_constants::collate)) _M_insert_char_matcher<true, false>(); else _M_insert_char_matcher<true, true>(); } while (false);
      else if (_M_match_token(_ScannerT::_S_token_backref))
 _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->
     _M_insert_backref(_M_cur_int_value(10))));
      else if (_M_match_token(_ScannerT::_S_token_quoted_class))
 do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_character_class_matcher<false, false>(); else _M_insert_character_class_matcher<false, true>(); else if (!(_M_flags & regex_constants::collate)) _M_insert_character_class_matcher<true, false>(); else _M_insert_character_class_matcher<true, true>(); } while (false);
      else if (_M_match_token(_ScannerT::_S_token_subexpr_no_group_begin))
 {
   _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_dummy());
   this->_M_disjunction();
   if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
     __throw_regex_error(regex_constants::error_paren);
   __r._M_append(_M_pop());
   _M_stack.push(__r);
 }
      else if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
 {
   _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_subexpr_begin());
   this->_M_disjunction();
   if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
     __throw_regex_error(regex_constants::error_paren);
   __r._M_append(_M_pop());
   __r._M_append(_M_nfa->_M_insert_subexpr_end());
   _M_stack.push(__r);
 }
      else if (!_M_bracket_expression())
 return false;
      return true;
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_bracket_expression()
    {
      bool __neg =
 _M_match_token(_ScannerT::_S_token_bracket_neg_begin);
      if (!(__neg || _M_match_token(_ScannerT::_S_token_bracket_begin)))
 return false;
      do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_bracket_matcher<false, false>(__neg); else _M_insert_bracket_matcher<false, true>(__neg); else if (!(_M_flags & regex_constants::collate)) _M_insert_bracket_matcher<true, false>(__neg); else _M_insert_bracket_matcher<true, true>(__neg); } while (false);
      return true;
    }


  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    void
    _Compiler<_TraitsT>::
    _M_insert_any_matcher_ecma()
    {
      _M_stack.push(_StateSeqT(*_M_nfa,
 _M_nfa->_M_insert_matcher
   (_AnyMatcher<_TraitsT, true, __icase, __collate>
     (_M_traits))));
    }

  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    void
    _Compiler<_TraitsT>::
    _M_insert_any_matcher_posix()
    {
      _M_stack.push(_StateSeqT(*_M_nfa,
 _M_nfa->_M_insert_matcher
   (_AnyMatcher<_TraitsT, false, __icase, __collate>
     (_M_traits))));
    }

  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    void
    _Compiler<_TraitsT>::
    _M_insert_char_matcher()
    {
      _M_stack.push(_StateSeqT(*_M_nfa,
 _M_nfa->_M_insert_matcher
   (_CharMatcher<_TraitsT, __icase, __collate>
     (_M_value[0], _M_traits))));
    }

  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    void
    _Compiler<_TraitsT>::
    _M_insert_character_class_matcher()
    {
      do { if (std::__is_constant_evaluated() && !bool(_M_value.size() == 1)) std::__glibcxx_assert_fail(); } while (false);
      _BracketMatcher<__icase, __collate> __matcher
 (_M_ctype.is(_CtypeT::upper, _M_value[0]), _M_traits);
      __matcher._M_add_character_class(_M_value, false);
      __matcher._M_ready();
      _M_stack.push(_StateSeqT(*_M_nfa,
 _M_nfa->_M_insert_matcher(std::move(__matcher))));
    }

  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    void
    _Compiler<_TraitsT>::
    _M_insert_bracket_matcher(bool __neg)
    {
      _BracketMatcher<__icase, __collate> __matcher(__neg, _M_traits);
      _BracketState __last_char;
      if (_M_try_char())
 __last_char.set(_M_value[0]);
      else if (_M_match_token(_ScannerT::_S_token_bracket_dash))

 __last_char.set('-');
      while (_M_expression_term(__last_char, __matcher))
 ;
      if (__last_char._M_is_char())
 __matcher._M_add_char(__last_char.get());
      __matcher._M_ready();
      _M_stack.push(_StateSeqT(
        *_M_nfa,
        _M_nfa->_M_insert_matcher(std::move(__matcher))));
    }

  template<typename _TraitsT>
  template<bool __icase, bool __collate>
    bool
    _Compiler<_TraitsT>::
    _M_expression_term(_BracketState& __last_char,
         _BracketMatcher<__icase, __collate>& __matcher)
    {
      if (_M_match_token(_ScannerT::_S_token_bracket_end))
 return false;


      const auto __push_char = [&](_CharT __ch)
      {
 if (__last_char._M_is_char())
   __matcher._M_add_char(__last_char.get());
 __last_char.set(__ch);
      };

      const auto __push_class = [&]
      {
        if (__last_char._M_is_char())
   __matcher._M_add_char(__last_char.get());


 __last_char.reset(_BracketState::_Type::_Class);
      };

      if (_M_match_token(_ScannerT::_S_token_collsymbol))
 {
   auto __symbol = __matcher._M_add_collate_element(_M_value);
   if (__symbol.size() == 1)
     __push_char(__symbol[0]);
   else
     __push_class();
 }
      else if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
 {
   __push_class();
   __matcher._M_add_equivalence_class(_M_value);
 }
      else if (_M_match_token(_ScannerT::_S_token_char_class_name))
 {
   __push_class();
   __matcher._M_add_character_class(_M_value, false);
 }
      else if (_M_try_char())
 __push_char(_M_value[0]);
# 489 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.tcc" 3
      else if (_M_match_token(_ScannerT::_S_token_bracket_dash))
 {
   if (_M_match_token(_ScannerT::_S_token_bracket_end))
     {

       __push_char('-');
       return false;
     }
   else if (__last_char._M_is_class())
     {

       __throw_regex_error(regex_constants::error_range,
      "Invalid start of '[x-x]' range in "
      "regular expression");
     }
   else if (__last_char._M_is_char())
     {
       if (_M_try_char())
  {

    __matcher._M_make_range(__last_char.get(), _M_value[0]);
    __last_char.reset();
  }
       else if (_M_match_token(_ScannerT::_S_token_bracket_dash))
  {

    __matcher._M_make_range(__last_char.get(), '-');
    __last_char.reset();
  }
       else
  __throw_regex_error(regex_constants::error_range,
        "Invalid end of '[x-x]' range in "
        "regular expression");
     }
   else if (_M_flags & regex_constants::ECMAScript)
     {



       __push_char('-');
     }
   else
     __throw_regex_error(regex_constants::error_range,
    "Invalid location of '-' within '[...]' in "
    "POSIX regular expression");
 }
      else if (_M_match_token(_ScannerT::_S_token_quoted_class))
 {
   __push_class();
   __matcher._M_add_character_class(_M_value,
        _M_ctype.is(_CtypeT::upper,
             _M_value[0]));
 }
      else
 __throw_regex_error(regex_constants::error_brack,
       "Unexpected character within '[...]' in "
       "regular expression");
      return true;
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_try_char()
    {
      bool __is_char = false;
      if (_M_match_token(_ScannerT::_S_token_oct_num))
 {
   __is_char = true;
   _M_value.assign(1, _M_cur_int_value(8));
 }
      else if (_M_match_token(_ScannerT::_S_token_hex_num))
 {
   __is_char = true;
   _M_value.assign(1, _M_cur_int_value(16));
 }
      else if (_M_match_token(_ScannerT::_S_token_ord_char))
 __is_char = true;
      return __is_char;
    }

  template<typename _TraitsT>
    bool
    _Compiler<_TraitsT>::
    _M_match_token(_TokenT __token)
    {
      if (__token == _M_scanner._M_get_token())
 {
   _M_value = _M_scanner._M_get_value();
   _M_scanner._M_advance();
   return true;
 }
      return false;
    }

  template<typename _TraitsT>
    int
    _Compiler<_TraitsT>::
    _M_cur_int_value(int __radix)
    {
      int __v = 0;
      for (_CharT __c : _M_value)
 if (__builtin_mul_overflow(__v, __radix, &__v)
     || __builtin_add_overflow(__v, _M_traits.value(__c, __radix), &__v))
     std::__throw_regex_error(regex_constants::error_backref,
         "invalid back reference");
      return __v;
    }

  template<typename _TraitsT, bool __icase, bool __collate>
    bool
    _BracketMatcher<_TraitsT, __icase, __collate>::
    _M_apply(_CharT __ch, false_type) const
    {
      return [this, __ch]
      {
 if (std::binary_search(_M_char_set.begin(), _M_char_set.end(),
          _M_translator._M_translate(__ch)))
   return true;
 auto __s = _M_translator._M_transform(__ch);
 for (auto& __it : _M_range_set)
   if (_M_translator._M_match_range(__it.first, __it.second, __s))
     return true;
 if (_M_traits.isctype(__ch, _M_class_set))
   return true;
 if (!_M_equiv_set.empty())
   {
     auto __x = _M_traits.transform_primary(&__ch, &__ch+1);
     auto __p = std::find(_M_equiv_set.begin(), _M_equiv_set.end(), __x);
     if (__p != _M_equiv_set.end())
       return true;
   }
 for (auto& __it : _M_neg_class_set)
   if (!_M_traits.isctype(__ch, __it))
     return true;
 return false;
      }() ^ _M_is_non_matching;
    }
}


}

#pragma GCC diagnostic pop
# 572 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_compiler.h" 2 3
# 70 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {
  template<typename, typename>
    class basic_regex;

  template<typename _Bi_iter, typename _Alloc>
    class match_results;

}

namespace __detail
{
  enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate };

  template<typename _BiIter, typename _Alloc,
    typename _CharT, typename _TraitsT>
    bool
    __regex_algo_impl(_BiIter __s, _BiIter __e,
        match_results<_BiIter, _Alloc>& __m,
        const basic_regex<_CharT, _TraitsT>& __re,
        regex_constants::match_flag_type __flags,
        _RegexExecutorPolicy __policy,
        bool __match_mode);

  template<typename, typename, typename, bool>
    class _Executor;

  template<typename _Tp>
    struct __is_contiguous_iter : false_type { };

  template<typename _Tp>
    struct __is_contiguous_iter<_Tp*> : true_type { };

  template<typename _Tp, typename _Cont>
    struct __is_contiguous_iter<__gnu_cxx::__normal_iterator<_Tp*, _Cont>>
    : true_type { };
}

namespace __cxx11 {
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type>
    class regex_traits
    {
    public:
      typedef _Ch_type char_type;
      typedef std::basic_string<char_type> string_type;
      typedef std::locale locale_type;

    private:
      struct _RegexMask
 {
   typedef std::ctype_base::mask _BaseType;
   _BaseType _M_base;
   unsigned char _M_extended;
   static constexpr unsigned char _S_under = 1 << 0;
   static constexpr unsigned char _S_valid_mask = 0x1;

   constexpr _RegexMask(_BaseType __base = 0,
          unsigned char __extended = 0)
   : _M_base(__base), _M_extended(__extended)
   { }

   constexpr _RegexMask
   operator&(_RegexMask __other) const
   {
     return _RegexMask(_M_base & __other._M_base,
         _M_extended & __other._M_extended);
   }

   constexpr _RegexMask
   operator|(_RegexMask __other) const
   {
     return _RegexMask(_M_base | __other._M_base,
         _M_extended | __other._M_extended);
   }

   constexpr _RegexMask
   operator^(_RegexMask __other) const
   {
     return _RegexMask(_M_base ^ __other._M_base,
         _M_extended ^ __other._M_extended);
   }

   constexpr _RegexMask
   operator~() const
   { return _RegexMask(~_M_base, ~_M_extended); }

   _RegexMask&
   operator&=(_RegexMask __other)
   { return *this = (*this) & __other; }

   _RegexMask&
   operator|=(_RegexMask __other)
   { return *this = (*this) | __other; }

   _RegexMask&
   operator^=(_RegexMask __other)
   { return *this = (*this) ^ __other; }

   constexpr bool
   operator==(_RegexMask __other) const
   {
     return (_M_extended & _S_valid_mask)
     == (__other._M_extended & _S_valid_mask)
       && _M_base == __other._M_base;
   }






 };

    public:
      typedef _RegexMask char_class_type;

    public:



      regex_traits() { }
# 191 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      static std::size_t
      length(const char_type* __p)
      { return string_type::traits_type::length(__p); }
# 202 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      char_type
      translate(char_type __c) const
      { return __c; }
# 215 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      char_type
      translate_nocase(char_type __c) const
      {
 typedef std::ctype<char_type> __ctype_type;
 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
 return __fctyp.tolower(__c);
      }
# 243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Fwd_iter>
 string_type
 transform(_Fwd_iter __first, _Fwd_iter __last) const
 {
   typedef std::collate<char_type> __collate_type;
   const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
   string_type __s(__first, __last);
   return __fclt.transform(__s.data(), __s.data() + __s.size());
 }
# 267 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Fwd_iter>
 string_type
 transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
 {
   string_type __ret;

   const auto& __fclt = use_facet<collate<char_type>>(_M_locale);
   if (typeid(__fclt) != typeid(collate<char_type>))
     return __ret;





   const auto& __fctyp(use_facet<ctype<char_type>>(_M_locale));
   basic_string<char_type> __s(__first, __last);
   const auto __p = const_cast<char_type*>(__s.c_str());
   const auto __pend = __p + __s.size();





   __fctyp.tolower(__p, __pend);

   try
     {
       __ret = __fclt.transform(__p, __pend);
     }
   catch(const exception&)
     {
     }

   return __ret;
 }
# 314 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Fwd_iter>
 string_type
 lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
# 355 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Fwd_iter>
 char_class_type
 lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
    bool __icase = false) const;
# 372 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      bool
      isctype(_Ch_type __c, char_class_type __f) const;
# 385 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      int
      value(_Ch_type __ch, int __radix) const;
# 399 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      locale_type
      imbue(locale_type __loc)
      {
 std::swap(_M_locale, __loc);
 return __loc;
      }





      locale_type
      getloc() const
      { return _M_locale; }

    protected:
      locale_type _M_locale;
    };
# 439 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
    class basic_regex
    {
    public:
      static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value,
      "regex traits class must have the same char_type");


      typedef _Ch_type value_type;
      typedef _Rx_traits traits_type;
      typedef typename traits_type::string_type string_type;
      typedef regex_constants::syntax_option_type flag_type;
      typedef typename traits_type::locale_type locale_type;






      static constexpr flag_type icase = regex_constants::icase;
      static constexpr flag_type nosubs = regex_constants::nosubs;
      static constexpr flag_type optimize = regex_constants::optimize;
      static constexpr flag_type collate = regex_constants::collate;
      static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
      static constexpr flag_type basic = regex_constants::basic;
      static constexpr flag_type extended = regex_constants::extended;
      static constexpr flag_type awk = regex_constants::awk;
      static constexpr flag_type grep = regex_constants::grep;
      static constexpr flag_type egrep = regex_constants::egrep;

      static constexpr flag_type multiline = regex_constants::multiline;
# 478 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex() noexcept
      : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)
      { }
# 493 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      explicit
      basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)
      { _M_compile(__p, __p + _Rx_traits::length(__p), __f); }
# 509 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex(const _Ch_type* __p, std::size_t __len,
    flag_type __f = ECMAScript)
      {
                                          ;
 _M_compile(__p, __p + __len, __f);
      }






      basic_regex(const basic_regex& __rhs) = default;






      basic_regex(basic_regex&& __rhs) noexcept = default;
# 539 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Ch_traits, typename _Ch_alloc>
 explicit
 basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
         _Ch_alloc>& __s,
      flag_type __f = ECMAScript)
 { _M_compile(__s.data(), __s.data() + __s.size(), __f); }
# 559 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _FwdIter>
 basic_regex(_FwdIter __first, _FwdIter __last,
      flag_type __f = ECMAScript)
 { this->assign(__first, __last, __f); }
# 572 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)
      { _M_compile(__l.begin(), __l.end(), __f); }




      ~basic_regex()
      { }




      basic_regex&
      operator=(const basic_regex&) = default;




      basic_regex&
      operator=(basic_regex&&) = default;
# 600 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex&
      operator=(const _Ch_type* __p)
      { return this->assign(__p); }
# 612 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex&
      operator=(initializer_list<_Ch_type> __l)
      { return this->assign(__l); }







      template<typename _Ch_traits, typename _Alloc>
 basic_regex&
 operator=(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s)
 { return this->assign(__s); }







      basic_regex&
      assign(const basic_regex& __rhs) noexcept
      { return *this = __rhs; }






      basic_regex&
      assign(basic_regex&& __rhs) noexcept
      { return *this = std::move(__rhs); }
# 659 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex&
      assign(const _Ch_type* __p, flag_type __flags = ECMAScript)
      {
 _M_compile(__p, __p + _Rx_traits::length(__p), __flags);
 return *this;
      }
# 681 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex&
      assign(const _Ch_type* __p, size_t __len, flag_type __flags = ECMAScript)
      {
 _M_compile(__p, __p + __len, __flags);
 return *this;
      }
# 699 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Ch_traits, typename _Alloc>
 basic_regex&
 assign(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s,
        flag_type __flags = ECMAScript)
 {
   _M_compile(__s.data(), __s.data() + __s.size(), __flags);
   return *this;
 }
# 721 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _InputIterator>
 basic_regex&
 assign(_InputIterator __first, _InputIterator __last,
        flag_type __flags = ECMAScript)
 {

   using _ValT = typename iterator_traits<_InputIterator>::value_type;
   if constexpr (__detail::__is_contiguous_iter<_InputIterator>::value
   && is_same_v<_ValT, value_type>)
     {
                                                      ;
       if constexpr (is_pointer_v<_InputIterator>)
  _M_compile(__first, __last, __flags);
       else
  _M_compile(__first.base(), __last.base(), __flags);
     }
   else

   this->assign(string_type(__first, __last), __flags);
   return *this;
 }
# 754 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      basic_regex&
      assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)
      {
 _M_compile(__l.begin(), __l.end(), __flags);
 return *this;
      }






      unsigned int
      mark_count() const noexcept
      {
 if (_M_automaton)
   return _M_automaton->_M_sub_count() - 1;
 return 0;
      }





      flag_type
      flags() const noexcept
      { return _M_flags; }







      locale_type
      imbue(locale_type __loc)
      {
 std::swap(__loc, _M_loc);
 _M_automaton.reset();
 return __loc;
      }





      locale_type
      getloc() const noexcept
      { return _M_loc; }







      void
      swap(basic_regex& __rhs) noexcept
      {
 std::swap(_M_flags, __rhs._M_flags);
 std::swap(_M_loc, __rhs._M_loc);
 std::swap(_M_automaton, __rhs._M_automaton);
      }







    private:
      typedef std::shared_ptr<const __detail::_NFA<_Rx_traits>> _AutomatonPtr;

      void
      _M_compile(const _Ch_type* __first, const _Ch_type* __last,
   flag_type __f)
      {
 __detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
 _M_automaton = __c._M_get_nfa();
 _M_flags = __f;
      }

      template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
 friend bool
 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
        const basic_regex<_Cp, _Rp>&,
        regex_constants::match_flag_type,
        __detail::_RegexExecutorPolicy, bool);

      template<typename, typename, typename, bool>
 friend class __detail::_Executor;

      flag_type _M_flags;
      locale_type _M_loc;
      _AutomatonPtr _M_automaton;
    };
# 894 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _ForwardIterator>
    basic_regex(_ForwardIterator, _ForwardIterator,
  regex_constants::syntax_option_type = {})
      -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;



  typedef basic_regex<char> regex;



  typedef basic_regex<wchar_t> wregex;
# 916 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, typename _Rx_traits>
    inline void
    swap(basic_regex<_Ch_type, _Rx_traits>& __lhs,
  basic_regex<_Ch_type, _Rx_traits>& __rhs) noexcept
    { __lhs.swap(__rhs); }
# 941 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _BiIter>
    class sub_match

    : public std::pair<_BiIter, _BiIter>

    {
      typedef iterator_traits<_BiIter> __iter_traits;

    public:
      typedef typename __iter_traits::value_type value_type;
      typedef typename __iter_traits::difference_type difference_type;
      typedef _BiIter iterator;
      typedef basic_string<value_type> string_type;



      bool matched;

      constexpr sub_match() noexcept : matched() { }


      difference_type
      length() const noexcept
      { return this->matched ? std::distance(this->first, this->second) : 0; }
# 976 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      operator string_type() const
      { return str(); }






      string_type
      str() const
      {
 return this->matched
   ? string_type(this->first, this->second)
   : string_type();
      }
# 1001 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      int
      compare(const sub_match& __s) const
      { return this->_M_str().compare(__s._M_str()); }
# 1015 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      int
      compare(const string_type& __s) const
      { return this->_M_str().compare(__s); }

      int
      compare(const value_type* __s) const
      { return this->_M_str().compare(__s); }




      int
      _M_compare(const value_type* __s, size_t __n) const
      { return this->_M_str().compare({__s, __n}); }





      void
      swap(sub_match& __s) noexcept(__is_nothrow_swappable<_BiIter>::value)
      {
 this->pair<_BiIter, _BiIter>::swap(__s);
 std::swap(matched, __s.matched);
      }

    private:

      struct __string_view
      {
 using traits_type = typename string_type::traits_type;

 __string_view() = default;

 __string_view(const value_type* __s, size_t __n) noexcept
 : _M_data(__s), _M_len(__n) { }

 __string_view(const value_type* __s) noexcept
 : _M_data(__s), _M_len(traits_type::length(__s)) { }

 __string_view(const string_type& __s) noexcept
 : _M_data(__s.data()), _M_len(__s.length()) { }

 int
 compare(__string_view __s) const noexcept
 {
   if (const size_t __n = std::min(_M_len, __s._M_len))
     if (int __ret = traits_type::compare(_M_data, __s._M_data, __n))
       return __ret;
   using __limits = __gnu_cxx::__int_traits<int>;
   const difference_type __diff = _M_len - __s._M_len;
   if (__diff > __limits::__max)
     return __limits::__max;
   if (__diff < __limits::__min)
     return __limits::__min;
   return static_cast<int>(__diff);
 }

      private:
 const value_type* _M_data = nullptr;
 size_t _M_len = 0;
      };


      template<typename _Iter = _BiIter>
 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
        __string_view>
 _M_str() const noexcept
 {
   if (this->matched)
     if (size_t __len = this->second - this->first)
       return { std::__addressof(*this->first), __len };
   return {};
 }


      template<typename _Iter = _BiIter>
 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
        string_type>
 _M_str() const
 { return str(); }
    };



  typedef sub_match<const char*> csub_match;


  typedef sub_match<string::const_iterator> ssub_match;



  typedef sub_match<const wchar_t*> wcsub_match;


  typedef sub_match<wstring::const_iterator> wssub_match;
# 1123 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _BiIter>
    inline bool
    operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
    { return __lhs.compare(__rhs) == 0; }
# 1136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _BiIter>
    inline auto
    operator<=>(const sub_match<_BiIter>& __lhs,
  const sub_match<_BiIter>& __rhs)
    noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
    {
      using _Tr = char_traits<typename iterator_traits<_BiIter>::value_type>;
      return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
    }
# 1205 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
    using __sub_match_string = basic_string<
         typename iterator_traits<_Bi_iter>::value_type,
         _Ch_traits, _Ch_alloc>;
# 1294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
    inline bool
    operator==(const sub_match<_Bi_iter>& __lhs,
        const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
    { return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
# 1308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Ch_traits, typename _Alloc>
    inline auto
    operator<=>(const sub_match<_Bi_iter>& __lhs,
  const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
    noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
    {
      return __detail::__char_traits_cmp_cat<_Ch_traits>(
   __lhs._M_compare(__rhs.data(), __rhs.size()));
    }
# 1461 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter>
    inline bool
    operator==(const sub_match<_Bi_iter>& __lhs,
        typename iterator_traits<_Bi_iter>::value_type const* __rhs)
    { return __lhs.compare(__rhs) == 0; }
# 1476 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter>
    inline auto
    operator<=>(const sub_match<_Bi_iter>& __lhs,
  typename iterator_traits<_Bi_iter>::value_type const* __rhs)
    noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
    {
      using _Tr = char_traits<typename iterator_traits<_Bi_iter>::value_type>;
      return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
    }
# 1633 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter>
    inline bool
    operator==(const sub_match<_Bi_iter>& __lhs,
        typename iterator_traits<_Bi_iter>::value_type const& __rhs)
    { return __lhs._M_compare(std::__addressof(__rhs), 1) == 0; }
# 1649 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter>
    inline auto
    operator<=>(const sub_match<_Bi_iter>& __lhs,
  typename iterator_traits<_Bi_iter>::value_type const& __rhs)
    noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
    {
      using _Tr = char_traits<typename iterator_traits<_Bi_iter>::value_type>;
      return __detail::__char_traits_cmp_cat<_Tr>(
   __lhs._M_compare(std::__addressof(__rhs), 1));
    }
# 1734 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
    inline
    basic_ostream<_Ch_type, _Ch_traits>&
    operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os,
        const sub_match<_Bi_iter>& __m)
    { return __os << __m.str(); }
# 1768 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter,
    typename _Alloc = allocator<sub_match<_Bi_iter> > >
    class match_results
    : private std::vector<sub_match<_Bi_iter>, _Alloc>
    {
    private:
# 1790 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      typedef std::vector<sub_match<_Bi_iter>, _Alloc> _Base_type;

      typedef std::vector<sub_match<_Bi_iter>, _Alloc> _Unchecked;
      typedef std::iterator_traits<_Bi_iter> __iter_traits;
      typedef regex_constants::match_flag_type match_flag_type;

    public:




      typedef sub_match<_Bi_iter> value_type;
      typedef const value_type& const_reference;
      typedef value_type& reference;
      typedef typename _Base_type::const_iterator const_iterator;
      typedef const_iterator iterator;
      typedef typename __iter_traits::difference_type difference_type;
      typedef typename allocator_traits<_Alloc>::size_type size_type;
      typedef _Alloc allocator_type;
      typedef typename __iter_traits::value_type char_type;
      typedef std::basic_string<char_type> string_type;


    public:
# 1823 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      match_results() : match_results(_Alloc()) { }





      explicit
      match_results(const _Alloc& __a) noexcept
      : _Base_type(__a)
      { }




      match_results(const match_results&) = default;




      match_results(match_results&&) noexcept = default;




      match_results&
      operator=(const match_results&) = default;




      match_results&
      operator=(match_results&&) = default;




      ~match_results() = default;




      match_results(const match_results& __m, const _Alloc& __a)
      : _Base_type(__m, __a) { }

      match_results(match_results&& __m, const _Alloc& __a)
      noexcept(noexcept(_Base_type(std::move(__m), __a)))
      : _Base_type(std::move(__m), __a) { }
# 1879 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      bool ready() const noexcept { return !_Unchecked::empty(); }
# 1895 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      size_type
      size() const noexcept
      { return _Unchecked::empty() ? 0 : _Unchecked::size() - 3; }

      size_type
      max_size() const noexcept
      { return _Unchecked::max_size() - 3; }






      [[__nodiscard__]] bool
      empty() const noexcept
      { return _Unchecked::size() <= 3; }
# 1927 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      difference_type
      length(size_type __sub = 0) const
      { return (*this)[__sub].length(); }
# 1942 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      difference_type
      position(size_type __sub = 0) const
      { return std::distance(_M_begin, (*this)[__sub].first); }
# 1955 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      string_type
      str(size_type __sub = 0) const
      { return string_type((*this)[__sub]); }
# 1970 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      const_reference
      operator[](size_type __sub) const
      {
 do { if (std::__is_constant_evaluated() && !bool(ready())) std::__glibcxx_assert_fail(); } while (false);
 return __sub < size()
        ? _Unchecked::operator[](__sub)
        : _M_unmatched_sub();
      }
# 1987 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      const_reference
      prefix() const
      {
 do { if (std::__is_constant_evaluated() && !bool(ready())) std::__glibcxx_assert_fail(); } while (false);
 return !empty() ? _M_prefix() : _M_unmatched_sub();
      }
# 2002 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      const_reference
      suffix() const
      {
 do { if (std::__is_constant_evaluated() && !bool(ready())) std::__glibcxx_assert_fail(); } while (false);
 return !empty() ? _M_suffix() : _M_unmatched_sub();
      }




      const_iterator
      begin() const noexcept
      { return _Base_type::begin(); }




      const_iterator
      cbegin() const noexcept
      { return this->begin(); }




      const_iterator
      end() const noexcept
      { return _Base_type::end() - (_Base_type::empty() ? 0 : 3); }




      const_iterator
      cend() const noexcept
      { return this->end(); }
# 2052 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<typename _Out_iter>
 _Out_iter
 format(_Out_iter __out, const char_type* __fmt_first,
        const char_type* __fmt_last,
        match_flag_type __flags = regex_constants::format_default) const;




      template<typename _Out_iter, typename _St, typename _Sa>
 _Out_iter
 format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
        match_flag_type __flags = regex_constants::format_default) const
 {
   return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
   __flags);
 }




      template<typename _St, typename _Sa>
 basic_string<char_type, _St, _Sa>
 format(const basic_string<char_type, _St, _Sa>& __fmt,
        match_flag_type __flags = regex_constants::format_default) const
 {
   basic_string<char_type, _St, _Sa> __result;
   format(std::back_inserter(__result), __fmt, __flags);
   return __result;
 }




      string_type
      format(const char_type* __fmt,
      match_flag_type __flags = regex_constants::format_default) const
      {
 string_type __result;
 format(std::back_inserter(__result),
        __fmt,
        __fmt + char_traits<char_type>::length(__fmt),
        __flags);
 return __result;
      }
# 2108 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      allocator_type
      get_allocator() const noexcept
      { return _Base_type::get_allocator(); }
# 2122 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      void
      swap(match_results& __that) noexcept
      {
 using std::swap;
 _Base_type::swap(__that);
 swap(_M_begin, __that._M_begin);
      }


    private:
      template<typename, typename, typename>
 friend class regex_iterator;



      template<typename, typename, typename, bool>
 friend class __detail::_Executor;

      template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
 friend bool
 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
        const basic_regex<_Cp, _Rp>&,
        regex_constants::match_flag_type,
        __detail::_RegexExecutorPolicy, bool);



      void
      _M_resize(unsigned int __size)
      { _Unchecked::assign(__size + 3, sub_match<_Bi_iter>{}); }


      void
      _M_establish_failed_match(_Bi_iter __end)
      {
 sub_match<_Bi_iter> __sm;
 __sm.first = __sm.second = __end;
 _Unchecked::assign(3, __sm);
      }

      const_reference
      _M_unmatched_sub() const
      { return _Unchecked::operator[](_Unchecked::size() - 3); }

      sub_match<_Bi_iter>&
      _M_unmatched_sub()
      { return _Unchecked::operator[](_Unchecked::size() - 3); }

      const_reference
      _M_prefix() const
      { return _Unchecked::operator[](_Unchecked::size() - 2); }

      sub_match<_Bi_iter>&
      _M_prefix()
      { return _Unchecked::operator[](_Unchecked::size() - 2); }

      const_reference
      _M_suffix() const
      { return _Unchecked::operator[](_Unchecked::size() - 1); }

      sub_match<_Bi_iter>&
      _M_suffix()
      { return _Unchecked::operator[](_Unchecked::size() - 1); }

      _Bi_iter _M_begin {};

    };

  typedef match_results<const char*> cmatch;
  typedef match_results<string::const_iterator> smatch;

  typedef match_results<const wchar_t*> wcmatch;
  typedef match_results<wstring::const_iterator> wsmatch;
# 2206 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Alloc>
    inline bool
    operator==(const match_results<_Bi_iter, _Alloc>& __m1,
        const match_results<_Bi_iter, _Alloc>& __m2)
    {
      if (__m1.ready() != __m2.ready())
 return false;
      if (!__m1.ready())
 return true;
      if (__m1.empty() != __m2.empty())
 return false;
      if (__m1.empty())
 return true;
      return __m1.prefix() == __m2.prefix()
 && __m1.size() == __m2.size()
 && std::equal(__m1.begin(), __m1.end(), __m2.begin())
 && __m1.suffix() == __m2.suffix();
    }
# 2250 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Alloc>
    inline void
    swap(match_results<_Bi_iter, _Alloc>& __lhs,
  match_results<_Bi_iter, _Alloc>& __rhs) noexcept
    { __lhs.swap(__rhs); }

}
# 2280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Alloc,
    typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_match(_Bi_iter __s,
  _Bi_iter __e,
  match_results<_Bi_iter, _Alloc>& __m,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __flags
          = regex_constants::match_default)
    {
      return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
 __detail::_RegexExecutorPolicy::_S_auto, true);
    }
# 2308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_match(_Bi_iter __first, _Bi_iter __last,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __flags
  = regex_constants::match_default)
    {
      match_results<_Bi_iter> __what;
      return regex_match(__first, __last, __what, __re, __flags);
    }
# 2333 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
    inline bool
    regex_match(const _Ch_type* __s,
  match_results<const _Ch_type*, _Alloc>& __m,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __f
  = regex_constants::match_default)
    { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
# 2356 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_traits, typename _Ch_alloc,
    typename _Alloc, typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
  match_results<typename basic_string<_Ch_type,
  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __flags
  = regex_constants::match_default)
    { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }




  template<typename _Ch_traits, typename _Ch_alloc,
    typename _Alloc, typename _Ch_type, typename _Rx_traits>
    bool
    regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
  match_results<typename basic_string<_Ch_type,
  _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
  const basic_regex<_Ch_type, _Rx_traits>&,
  regex_constants::match_flag_type
  = regex_constants::match_default) = delete;
# 2393 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, class _Rx_traits>
    inline bool
    regex_match(const _Ch_type* __s,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __f
  = regex_constants::match_default)
    { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
# 2414 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_traits, typename _Str_allocator,
    typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s,
  const basic_regex<_Ch_type, _Rx_traits>& __re,
  regex_constants::match_flag_type __flags
  = regex_constants::match_default)
    { return regex_match(__s.begin(), __s.end(), __re, __flags); }
# 2437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Alloc,
    typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_search(_Bi_iter __s, _Bi_iter __e,
   match_results<_Bi_iter, _Alloc>& __m,
   const basic_regex<_Ch_type, _Rx_traits>& __re,
   regex_constants::match_flag_type __flags
   = regex_constants::match_default)
    {
      return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
 __detail::_RegexExecutorPolicy::_S_auto, false);
    }
# 2461 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_search(_Bi_iter __first, _Bi_iter __last,
   const basic_regex<_Ch_type, _Rx_traits>& __re,
   regex_constants::match_flag_type __flags
   = regex_constants::match_default)
    {
      match_results<_Bi_iter> __what;
      return regex_search(__first, __last, __what, __re, __flags);
    }
# 2484 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, class _Alloc, class _Rx_traits>
    inline bool
    regex_search(const _Ch_type* __s,
   match_results<const _Ch_type*, _Alloc>& __m,
   const basic_regex<_Ch_type, _Rx_traits>& __e,
   regex_constants::match_flag_type __f
   = regex_constants::match_default)
    { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
# 2503 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_search(const _Ch_type* __s,
   const basic_regex<_Ch_type, _Rx_traits>& __e,
   regex_constants::match_flag_type __f
   = regex_constants::match_default)
    { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
# 2521 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_traits, typename _String_allocator,
    typename _Ch_type, typename _Rx_traits>
    inline bool
    regex_search(const basic_string<_Ch_type, _Ch_traits,
   _String_allocator>& __s,
   const basic_regex<_Ch_type, _Rx_traits>& __e,
   regex_constants::match_flag_type __flags
   = regex_constants::match_default)
    { return regex_search(__s.begin(), __s.end(), __e, __flags); }
# 2543 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Ch_traits, typename _Ch_alloc,
    typename _Alloc, typename _Ch_type,
    typename _Rx_traits>
    inline bool
    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s,
   match_results<typename basic_string<_Ch_type,
   _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
   const basic_regex<_Ch_type, _Rx_traits>& __e,
   regex_constants::match_flag_type __f
   = regex_constants::match_default)
    { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }




  template<typename _Ch_traits, typename _Ch_alloc,
    typename _Alloc, typename _Ch_type,
    typename _Rx_traits>
    bool
    regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&,
   match_results<typename basic_string<_Ch_type,
   _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
   const basic_regex<_Ch_type, _Rx_traits>&,
   regex_constants::match_flag_type
   = regex_constants::match_default) = delete;




  template<typename _Out_iter, typename _Bi_iter,
    typename _Rx_traits, typename _Ch_type>
    _Out_iter
    __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
      const basic_regex<_Ch_type, _Rx_traits>& __e,
      const _Ch_type* __fmt, size_t __len,
      regex_constants::match_flag_type __flags);
# 2594 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Out_iter, typename _Bi_iter,
    typename _Rx_traits, typename _Ch_type,
    typename _St, typename _Sa>
    inline _Out_iter
    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const basic_string<_Ch_type, _St, _Sa>& __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      return std::__regex_replace(__out, __first, __last, __e, __fmt.c_str(),
      __fmt.length(), __flags);
    }
# 2621 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Out_iter, typename _Bi_iter,
    typename _Rx_traits, typename _Ch_type>
    _Out_iter
    regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const _Ch_type* __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      return std::__regex_replace(__out, __first, __last, __e, __fmt,
      char_traits<_Ch_type>::length(__fmt),
      __flags);
    }
# 2647 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Rx_traits, typename _Ch_type,
    typename _St, typename _Sa, typename _Fst, typename _Fsa>
    inline basic_string<_Ch_type, _St, _Sa>
    regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const basic_string<_Ch_type, _Fst, _Fsa>& __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      basic_string<_Ch_type, _St, _Sa> __result;
      regex_replace(std::back_inserter(__result),
      __s.begin(), __s.end(), __e, __fmt, __flags);
      return __result;
    }
# 2673 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Rx_traits, typename _Ch_type,
    typename _St, typename _Sa>
    inline basic_string<_Ch_type, _St, _Sa>
    regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const _Ch_type* __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      basic_string<_Ch_type, _St, _Sa> __result;
      regex_replace(std::back_inserter(__result),
      __s.begin(), __s.end(), __e, __fmt, __flags);
      return __result;
    }
# 2699 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Rx_traits, typename _Ch_type,
    typename _St, typename _Sa>
    inline basic_string<_Ch_type>
    regex_replace(const _Ch_type* __s,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const basic_string<_Ch_type, _St, _Sa>& __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      basic_string<_Ch_type> __result;
      regex_replace(std::back_inserter(__result), __s,
      __s + char_traits<_Ch_type>::length(__s),
      __e, __fmt, __flags);
      return __result;
    }
# 2726 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Rx_traits, typename _Ch_type>
    inline basic_string<_Ch_type>
    regex_replace(const _Ch_type* __s,
    const basic_regex<_Ch_type, _Rx_traits>& __e,
    const _Ch_type* __fmt,
    regex_constants::match_flag_type __flags
    = regex_constants::match_default)
    {
      basic_string<_Ch_type> __result;
      regex_replace(std::back_inserter(__result), __s,
      __s + char_traits<_Ch_type>::length(__s),
      __e, __fmt, __flags);
      return __result;
    }



namespace __cxx11 {
# 2753 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter,
    typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
    typename _Rx_traits = regex_traits<_Ch_type> >
    class regex_iterator
    {
    public:
      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
      typedef match_results<_Bi_iter> value_type;
      typedef std::ptrdiff_t difference_type;
      typedef const value_type* pointer;
      typedef const value_type& reference;
      typedef std::forward_iterator_tag iterator_category;

      typedef std::input_iterator_tag iterator_concept;






      regex_iterator() = default;
# 2782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
       regex_constants::match_flag_type __m
       = regex_constants::match_default)
      : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
      {
 if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
   *this = regex_iterator();
      }



      regex_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
       regex_constants::match_flag_type
       = regex_constants::match_default) = delete;


      regex_iterator(const regex_iterator&) = default;


      regex_iterator&
      operator=(const regex_iterator&) = default;

      ~regex_iterator() = default;




      bool
      operator==(const regex_iterator&) const noexcept;




      bool operator==(default_sentinel_t) const noexcept
      { return _M_pregex == nullptr; }
# 2831 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      const value_type&
      operator*() const noexcept
      { return _M_match; }




      const value_type*
      operator->() const noexcept
      { return &_M_match; }




      regex_iterator&
      operator++();




      regex_iterator
      operator++(int)
      {
 auto __tmp = *this;
 ++(*this);
 return __tmp;
      }

    private:
      _Bi_iter _M_begin {};
      _Bi_iter _M_end {};
      const regex_type* _M_pregex = nullptr;
      regex_constants::match_flag_type _M_flags {};
      match_results<_Bi_iter> _M_match;
    };

  typedef regex_iterator<const char*> cregex_iterator;
  typedef regex_iterator<string::const_iterator> sregex_iterator;

  typedef regex_iterator<const wchar_t*> wcregex_iterator;
  typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
# 2885 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
  template<typename _Bi_iter,
    typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
    typename _Rx_traits = regex_traits<_Ch_type> >
    class regex_token_iterator
    {
    public:
      typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
      typedef sub_match<_Bi_iter> value_type;
      typedef std::ptrdiff_t difference_type;
      typedef const value_type* pointer;
      typedef const value_type& reference;
      typedef std::forward_iterator_tag iterator_category;

      typedef std::input_iterator_tag iterator_concept;


    public:







      regex_token_iterator()
      : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
      _M_has_m1(false)
      { }
# 2931 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
      int __submatch = 0,
      regex_constants::match_flag_type __m
      = regex_constants::match_default)
      : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
      { _M_init(__a, __b); }
# 2947 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
      const regex_type& __re,
      const std::vector<int>& __submatches,
      regex_constants::match_flag_type __m
        = regex_constants::match_default)
      : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
      { _M_init(__a, __b); }
# 2964 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
      const regex_type& __re,
      initializer_list<int> __submatches,
      regex_constants::match_flag_type __m
        = regex_constants::match_default)
      : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
      { _M_init(__a, __b); }
# 2981 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      template<std::size_t _Nm>
 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
        const regex_type& __re,
        const int (&__submatches)[_Nm],
        regex_constants::match_flag_type __m
        = regex_constants::match_default)
      : _M_position(__a, __b, __re, __m),
      _M_subs(__submatches, __submatches + _Nm), _M_n(0)
      { _M_init(__a, __b); }



      regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, int = 0,
      regex_constants::match_flag_type =
      regex_constants::match_default) = delete;
      regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
      const std::vector<int>&,
      regex_constants::match_flag_type =
      regex_constants::match_default) = delete;
      regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
      initializer_list<int>,
      regex_constants::match_flag_type =
      regex_constants::match_default) = delete;
      template <std::size_t _Nm>
 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
        const int (&)[_Nm],
        regex_constants::match_flag_type =
        regex_constants::match_default) = delete;





      regex_token_iterator(const regex_token_iterator& __rhs)
      : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
      _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
      { _M_normalize_result(); }





      regex_token_iterator&
      operator=(const regex_token_iterator& __rhs);




      bool
      operator==(const regex_token_iterator& __rhs) const;




      bool operator==(default_sentinel_t) const noexcept
      { return _M_end_of_seq(); }
# 3051 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 3
      const value_type&
      operator*() const
      { return *_M_result; }




      const value_type*
      operator->() const
      { return _M_result; }




      regex_token_iterator&
      operator++();




      regex_token_iterator
      operator++(int)
      {
 auto __tmp = *this;
 ++(*this);
 return __tmp;
      }

    private:
      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position;

      void
      _M_init(_Bi_iter __a, _Bi_iter __b);

      const value_type&
      _M_current_match() const
      {
 if (_M_subs[_M_n] == -1)
   return (*_M_position).prefix();
 else
   return (*_M_position)[_M_subs[_M_n]];
      }

      constexpr bool
      _M_end_of_seq() const noexcept
      { return _M_result == nullptr; }


      void
      _M_normalize_result()
      {
 if (_M_position != _Position())
   _M_result = &_M_current_match();
 else if (_M_has_m1)
   _M_result = &_M_suffix;
 else
   _M_result = nullptr;
      }

      _Position _M_position;
      std::vector<int> _M_subs;
      value_type _M_suffix;
      std::size_t _M_n;
      const value_type* _M_result;


      bool _M_has_m1;
    };


  typedef regex_token_iterator<const char*> cregex_token_iterator;


  typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;



  typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;


  typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;




}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.tcc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.tcc" 3
  template<typename _BiIter, typename _Alloc,
    typename _CharT, typename _TraitsT>
    bool
    __regex_algo_impl(_BiIter __s,
        _BiIter __e,
        match_results<_BiIter, _Alloc>& __m,
        const basic_regex<_CharT, _TraitsT>& __re,
        regex_constants::match_flag_type __flags,
        _RegexExecutorPolicy __policy,
        bool __match_mode)
    {
      if (__re._M_automaton == nullptr)
 return false;

      typename match_results<_BiIter, _Alloc>::_Unchecked& __res = __m;
      __m._M_begin = __s;
      __m._M_resize(__re._M_automaton->_M_sub_count());

      bool __ret;
      if ((__re.flags() & regex_constants::__polynomial)
   || (__policy == _RegexExecutorPolicy::_S_alternate
       && !__re._M_automaton->_M_has_backref))
 {
   _Executor<_BiIter, _Alloc, _TraitsT, false>
     __executor(__s, __e, __res, __re, __flags);
   if (__match_mode)
     __ret = __executor._M_match();
   else
     __ret = __executor._M_search();
 }
      else
 {
   _Executor<_BiIter, _Alloc, _TraitsT, true>
     __executor(__s, __e, __res, __re, __flags);
   if (__match_mode)
     __ret = __executor._M_match();
   else
     __ret = __executor._M_search();
 }
      if (__ret)
 {
   for (auto& __it : __res)
     if (!__it.matched)
       __it.first = __it.second = __e;
   auto& __pre = __m._M_prefix();
   auto& __suf = __m._M_suffix();
   if (__match_mode)
     {
       __pre.matched = false;
       __pre.first = __s;
       __pre.second = __s;
       __suf.matched = false;
       __suf.first = __e;
       __suf.second = __e;
     }
   else
     {
       __pre.first = __s;
       __pre.second = __res[0].first;
       __pre.matched = (__pre.first != __pre.second);
       __suf.first = __res[0].second;
       __suf.second = __e;
       __suf.matched = (__suf.first != __suf.second);
     }
 }
      else
 {
   __m._M_establish_failed_match(__e);
 }
      return __ret;
    }

}

  template<typename _Ch_type>
  template<typename _Fwd_iter>
    typename regex_traits<_Ch_type>::string_type
    regex_traits<_Ch_type>::
    lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
    {
      typedef std::ctype<char_type> __ctype_type;
      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));

      static const char* __collatenames[] =
 {
   "NUL",
   "SOH",
   "STX",
   "ETX",
   "EOT",
   "ENQ",
   "ACK",
   "alert",
   "backspace",
   "tab",
   "newline",
   "vertical-tab",
   "form-feed",
   "carriage-return",
   "SO",
   "SI",
   "DLE",
   "DC1",
   "DC2",
   "DC3",
   "DC4",
   "NAK",
   "SYN",
   "ETB",
   "CAN",
   "EM",
   "SUB",
   "ESC",
   "IS4",
   "IS3",
   "IS2",
   "IS1",
   "space",
   "exclamation-mark",
   "quotation-mark",
   "number-sign",
   "dollar-sign",
   "percent-sign",
   "ampersand",
   "apostrophe",
   "left-parenthesis",
   "right-parenthesis",
   "asterisk",
   "plus-sign",
   "comma",
   "hyphen",
   "period",
   "slash",
   "zero",
   "one",
   "two",
   "three",
   "four",
   "five",
   "six",
   "seven",
   "eight",
   "nine",
   "colon",
   "semicolon",
   "less-than-sign",
   "equals-sign",
   "greater-than-sign",
   "question-mark",
   "commercial-at",
   "A",
   "B",
   "C",
   "D",
   "E",
   "F",
   "G",
   "H",
   "I",
   "J",
   "K",
   "L",
   "M",
   "N",
   "O",
   "P",
   "Q",
   "R",
   "S",
   "T",
   "U",
   "V",
   "W",
   "X",
   "Y",
   "Z",
   "left-square-bracket",
   "backslash",
   "right-square-bracket",
   "circumflex",
   "underscore",
   "grave-accent",
   "a",
   "b",
   "c",
   "d",
   "e",
   "f",
   "g",
   "h",
   "i",
   "j",
   "k",
   "l",
   "m",
   "n",
   "o",
   "p",
   "q",
   "r",
   "s",
   "t",
   "u",
   "v",
   "w",
   "x",
   "y",
   "z",
   "left-curly-bracket",
   "vertical-line",
   "right-curly-bracket",
   "tilde",
   "DEL",
 };

      string __s;
      for (; __first != __last; ++__first)
 __s += __fctyp.narrow(*__first, 0);

      for (const auto& __it : __collatenames)
 if (__s == __it)
   return string_type(1, __fctyp.widen(
     static_cast<char>(&__it - __collatenames)));




      return string_type();
    }

  template<typename _Ch_type>
  template<typename _Fwd_iter>
    typename regex_traits<_Ch_type>::char_class_type
    regex_traits<_Ch_type>::
    lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase) const
    {
      typedef std::ctype<char_type> __ctype_type;
      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));


      static const pair<const char*, char_class_type> __classnames[] =
      {
 {"d", ctype_base::digit},
 {"w", {ctype_base::alnum, _RegexMask::_S_under}},
 {"s", ctype_base::space},
 {"alnum", ctype_base::alnum},
 {"alpha", ctype_base::alpha},
 {"blank", ctype_base::blank},
 {"cntrl", ctype_base::cntrl},
 {"digit", ctype_base::digit},
 {"graph", ctype_base::graph},
 {"lower", ctype_base::lower},
 {"print", ctype_base::print},
 {"punct", ctype_base::punct},
 {"space", ctype_base::space},
 {"upper", ctype_base::upper},
 {"xdigit", ctype_base::xdigit},
      };

      string __s;
      for (; __first != __last; ++__first)
 __s += __fctyp.narrow(__fctyp.tolower(*__first), 0);

      for (const auto& __it : __classnames)
 if (__s == __it.first)
   {
     if (__icase
  && ((__it.second
       & (ctype_base::lower | ctype_base::upper)) != 0))
       return ctype_base::alpha;
     return __it.second;
   }
      return 0;
    }

  template<typename _Ch_type>
    bool
    regex_traits<_Ch_type>::
    isctype(_Ch_type __c, char_class_type __f) const
    {
      typedef std::ctype<char_type> __ctype_type;
      const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));

      return __fctyp.is(__f._M_base, __c)

 || ((__f._M_extended & _RegexMask::_S_under)
     && __c == __fctyp.widen('_'));
    }

  template<typename _Ch_type>
    int
    regex_traits<_Ch_type>::
    value(_Ch_type __ch, int __radix) const
    {
      std::basic_istringstream<char_type> __is(string_type(1, __ch));
      long __v;
      if (__radix == 8)
 __is >> std::oct;
      else if (__radix == 16)
 __is >> std::hex;
      __is >> __v;
      return __is.fail() ? -1 : __v;
    }

  template<typename _Bi_iter, typename _Alloc>
  template<typename _Out_iter>
    _Out_iter
    match_results<_Bi_iter, _Alloc>::
    format(_Out_iter __out,
    const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first,
    const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last,
    match_flag_type __flags) const
    {
      do { if (std::__is_constant_evaluated() && !bool(ready())) std::__glibcxx_assert_fail(); } while (false);
      regex_traits<char_type> __traits;
      typedef std::ctype<char_type> __ctype_type;
      const __ctype_type&
 __fctyp(use_facet<__ctype_type>(__traits.getloc()));

      auto __output = [&](size_t __idx)
 {
   auto& __sub = (*this)[__idx];
   if (__sub.matched)
     __out = std::copy(__sub.first, __sub.second, __out);
 };

      if (__flags & regex_constants::format_sed)
 {
   bool __escaping = false;
   for (; __fmt_first != __fmt_last; __fmt_first++)
     {
       if (__escaping)
  {
    __escaping = false;
    if (__fctyp.is(__ctype_type::digit, *__fmt_first))
      __output(__traits.value(*__fmt_first, 10));
    else
      *__out++ = *__fmt_first;
    continue;
  }
       if (*__fmt_first == '\\')
  {
    __escaping = true;
    continue;
  }
       if (*__fmt_first == '&')
  {
    __output(0);
    continue;
  }
       *__out++ = *__fmt_first;
     }
   if (__escaping)
     *__out++ = '\\';
 }
      else
 {
   while (1)
     {
       auto __next = std::find(__fmt_first, __fmt_last, '$');
       if (__next == __fmt_last)
  break;

       __out = std::copy(__fmt_first, __next, __out);

       auto __eat = [&](char __ch) -> bool
  {
    if (*__next == __ch)
      {
        ++__next;
        return true;
      }
    return false;
  };

       if (++__next == __fmt_last)
  *__out++ = '$';
       else if (__eat('$'))
  *__out++ = '$';
       else if (__eat('&'))
  __output(0);
       else if (__eat('`'))
  {
    auto& __sub = _M_prefix();
    if (__sub.matched)
      __out = std::copy(__sub.first, __sub.second, __out);
  }
       else if (__eat('\''))
  {
    auto& __sub = _M_suffix();
    if (__sub.matched)
      __out = std::copy(__sub.first, __sub.second, __out);
  }
       else if (__fctyp.is(__ctype_type::digit, *__next))
  {
    long __num = __traits.value(*__next, 10);
    if (++__next != __fmt_last
        && __fctyp.is(__ctype_type::digit, *__next))
      {
        __num *= 10;
        __num += __traits.value(*__next++, 10);
      }
    if (0 <= __num && size_t(__num) < this->size())
      __output(__num);
  }
       else
  *__out++ = '$';
       __fmt_first = __next;
     }
   __out = std::copy(__fmt_first, __fmt_last, __out);
 }
      return __out;
    }

  template<typename _Out_iter, typename _Bi_iter,
    typename _Rx_traits, typename _Ch_type>
    _Out_iter
    __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
      const basic_regex<_Ch_type, _Rx_traits>& __e,
      const _Ch_type* __fmt, size_t __len,
      regex_constants::match_flag_type __flags)
    {
      typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _IterT;
      _IterT __i(__first, __last, __e, __flags);
      _IterT __end;
      if (__i == __end)
 {
   if (!(__flags & regex_constants::format_no_copy))
     __out = std::copy(__first, __last, __out);
 }
      else
 {
   sub_match<_Bi_iter> __last;
   for (; __i != __end; ++__i)
     {
       if (!(__flags & regex_constants::format_no_copy))
  __out = std::copy(__i->prefix().first, __i->prefix().second,
      __out);
       __out = __i->format(__out, __fmt, __fmt + __len, __flags);
       __last = __i->suffix();
       if (__flags & regex_constants::format_first_only)
  break;
     }
   if (!(__flags & regex_constants::format_no_copy))
     __out = std::copy(__last.first, __last.second, __out);
 }
      return __out;
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    bool
    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    operator==(const regex_iterator& __rhs) const noexcept
    {
      if (_M_pregex == nullptr && __rhs._M_pregex == nullptr)
 return true;
      return _M_pregex == __rhs._M_pregex
   && _M_begin == __rhs._M_begin
   && _M_end == __rhs._M_end
   && _M_flags == __rhs._M_flags
   && _M_match[0] == __rhs._M_match[0];
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
    regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    operator++()
    {






      if (_M_match[0].matched)
 {
   auto __start = _M_match[0].second;
   auto __prefix_first = _M_match[0].second;
   if (_M_match[0].first == _M_match[0].second)
     {
       if (__start == _M_end)
  {
    _M_pregex = nullptr;
    return *this;
  }
       else
  {
    if (regex_search(__start, _M_end, _M_match, *_M_pregex,
       _M_flags
       | regex_constants::match_not_null
       | regex_constants::match_continuous))
      {
        do { if (std::__is_constant_evaluated() && !bool(_M_match[0].matched)) std::__glibcxx_assert_fail(); } while (false);
        auto& __prefix = _M_match._M_prefix();
        __prefix.first = __prefix_first;
        __prefix.matched = __prefix.first != __prefix.second;

        _M_match._M_begin = _M_begin;
        return *this;
      }
    else
      ++__start;
  }
     }
   _M_flags |= regex_constants::match_prev_avail;
   if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags))
     {
       do { if (std::__is_constant_evaluated() && !bool(_M_match[0].matched)) std::__glibcxx_assert_fail(); } while (false);
       auto& __prefix = _M_match._M_prefix();
       __prefix.first = __prefix_first;
       __prefix.matched = __prefix.first != __prefix.second;

       _M_match._M_begin = _M_begin;
     }
   else
     _M_pregex = nullptr;
 }
      return *this;
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    operator=(const regex_token_iterator& __rhs)
    {
      _M_position = __rhs._M_position;
      _M_subs = __rhs._M_subs;
      _M_n = __rhs._M_n;
      _M_suffix = __rhs._M_suffix;
      _M_has_m1 = __rhs._M_has_m1;
      _M_normalize_result();
      return *this;
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    bool
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    operator==(const regex_token_iterator& __rhs) const
    {
      if (_M_end_of_seq() && __rhs._M_end_of_seq())
 return true;
      if (_M_suffix.matched && __rhs._M_suffix.matched
   && _M_suffix == __rhs._M_suffix)
 return true;
      if (_M_end_of_seq() || _M_suffix.matched
   || __rhs._M_end_of_seq() || __rhs._M_suffix.matched)
 return false;
      return _M_position == __rhs._M_position
 && _M_n == __rhs._M_n
 && _M_subs == __rhs._M_subs;
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>&
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    operator++()
    {
      _Position __prev = _M_position;
      if (_M_suffix.matched)
 *this = regex_token_iterator();
      else if (_M_n + 1 < _M_subs.size())
 {
   _M_n++;
   _M_result = &_M_current_match();
 }
      else
 {
   _M_n = 0;
   ++_M_position;
   if (_M_position != _Position())
     _M_result = &_M_current_match();
   else if (_M_has_m1 && __prev->suffix().length() != 0)
     {
       _M_suffix.matched = true;
       _M_suffix.first = __prev->suffix().first;
       _M_suffix.second = __prev->suffix().second;
       _M_result = &_M_suffix;
     }
   else
     *this = regex_token_iterator();
 }
      return *this;
    }

  template<typename _Bi_iter,
    typename _Ch_type,
    typename _Rx_traits>
    void
    regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>::
    _M_init(_Bi_iter __a, _Bi_iter __b)
    {
      _M_has_m1 = false;
      for (auto __it : _M_subs)
 if (__it == -1)
   {
     _M_has_m1 = true;
     break;
   }
      if (_M_position != _Position())
 _M_result = &_M_current_match();
      else if (_M_has_m1)
 {
   _M_suffix.matched = true;
   _M_suffix.first = __a;
   _M_suffix.second = __b;
   _M_result = &_M_suffix;
 }
      else
 _M_result = nullptr;
    }


}
# 3141 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex.h" 2 3
# 71 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.h" 3
  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    class _Executor
    {
      using __search_mode = integral_constant<bool, __dfs_mode>;
      using __dfs = true_type;
      using __bfs = false_type;

      enum class _Match_mode : unsigned char { _Exact, _Prefix };

    public:
      typedef typename iterator_traits<_BiIter>::value_type _CharT;
      typedef basic_regex<_CharT, _TraitsT> _RegexT;
      typedef std::vector<sub_match<_BiIter>, _Alloc> _ResultsVec;
      typedef regex_constants::match_flag_type _FlagT;
      typedef typename _TraitsT::char_class_type _ClassT;
      typedef _NFA<_TraitsT> _NFAT;

    public:
      _Executor(_BiIter __begin,
  _BiIter __end,
  _ResultsVec& __results,
  const _RegexT& __re,
  _FlagT __flags)
      : _M_cur_results(__results.get_allocator()),
 _M_begin(__begin),
 _M_end(__end),
 _M_re(__re),
 _M_nfa(*__re._M_automaton),
 _M_results(__results),
 _M_rep_count(_M_nfa.size()),
 _M_states(_M_nfa._M_start(), _M_nfa.size()),
 _M_flags(__flags)
      {
 using namespace regex_constants;
 if (__flags & match_prev_avail)
   _M_flags &= ~(match_not_bol | match_not_bow);
      }


      bool
      _M_match()
      {
 _M_current = _M_begin;
 return _M_main(_Match_mode::_Exact);
      }


      bool
      _M_search_from_first()
      {
 _M_current = _M_begin;
 return _M_main(_Match_mode::_Prefix);
      }

      bool
      _M_search();

    private:
      void
      _M_rep_once_more(_Match_mode __match_mode, _StateIdT);

      void
      _M_handle_repeat(_Match_mode, _StateIdT);

      void
      _M_handle_subexpr_begin(_Match_mode, _StateIdT);

      void
      _M_handle_subexpr_end(_Match_mode, _StateIdT);

      void
      _M_handle_line_begin_assertion(_Match_mode, _StateIdT);

      void
      _M_handle_line_end_assertion(_Match_mode, _StateIdT);

      void
      _M_handle_word_boundary(_Match_mode, _StateIdT);

      void
      _M_handle_subexpr_lookahead(_Match_mode, _StateIdT);

      void
      _M_handle_match(_Match_mode, _StateIdT);

      void
      _M_handle_backref(_Match_mode, _StateIdT);

      void
      _M_handle_accept(_Match_mode, _StateIdT);

      void
      _M_handle_alternative(_Match_mode, _StateIdT);

      void
      _M_dfs(_Match_mode __match_mode, _StateIdT __start);

      bool
      _M_main(_Match_mode __match_mode)
      { return _M_main_dispatch(__match_mode, __search_mode{}); }

      bool
      _M_main_dispatch(_Match_mode __match_mode, __dfs);

      bool
      _M_main_dispatch(_Match_mode __match_mode, __bfs);

      bool
      _M_is_word(_CharT __ch) const
      {
 static const _CharT __s[2] = { 'w' };
 return _M_re._M_automaton->_M_traits.isctype
   (__ch, _M_re._M_automaton->_M_traits.lookup_classname(__s, __s+1));
      }

      bool
      _M_at_begin() const
      {
 if (_M_current == _M_begin)
   {

     if (_M_flags & regex_constants::match_not_bol)
       return false;

     if (_M_flags & regex_constants::match_prev_avail)
       {


  if (_M_match_multiline())
    return _M_is_line_terminator(*std::prev(_M_current));
  else
    return false;
       }
     else
       return true;
   }
 else if (_M_match_multiline())
   return _M_is_line_terminator(*std::prev(_M_current));
 else
   return false;
      }

      bool
      _M_at_end() const
      {
 if (_M_current == _M_end)
   return !(_M_flags & regex_constants::match_not_eol);
 else if (_M_match_multiline())
   return _M_is_line_terminator(*_M_current);
 else
   return false;
      }

      bool
      _M_word_boundary() const;

      bool
      _M_lookahead(_StateIdT __next);

      bool
      _M_is_line_terminator(_CharT __c) const
      {
 const auto& __traits = _M_re._M_automaton->_M_traits;
 const auto& __ct = use_facet<ctype<_CharT>>(__traits.getloc());
 const char __n{ __ct.narrow(__c, ' ') };
 if (__n == '\n')
   return true;
 if (_M_re._M_automaton->_M_options() & regex_constants::ECMAScript)
   {
     if (__n == '\r')
       return true;

   }
 return false;
      }

      bool
      _M_match_multiline() const noexcept
      {
 constexpr auto __m
   = regex_constants::ECMAScript | regex_constants::__multiline;
 return (_M_re._M_automaton->_M_options() & __m) == __m;
      }


      template<typename _SearchMode, typename _ResultsVec>
 struct _State_info;

      template<typename _ResultsVec>
 struct _State_info<__bfs, _ResultsVec>
 {
   explicit
   _State_info(_StateIdT __start, size_t __n)
   : _M_visited_states(new bool[__n]()), _M_start(__start)
   { }

   ~_State_info() { delete[] _M_visited_states; }

   _State_info(const _State_info&) = delete;
   _State_info& operator=(const _State_info&) = delete;

   bool _M_visited(_StateIdT __i)
   {
     if (_M_visited_states[__i])
       return true;
     _M_visited_states[__i] = true;
     return false;
   }

   void _M_queue(_StateIdT __i, const _ResultsVec& __res)
   { _M_match_queue.emplace_back(__i, __res); }


   _BiIter* _M_get_sol_pos() { return nullptr; }


   std::vector<pair<_StateIdT, _ResultsVec>> _M_match_queue;

   bool* _M_visited_states;

   _StateIdT _M_start;
 };

      template<typename _ResultsVec>
 struct _State_info<__dfs, _ResultsVec>
 {
   explicit
   _State_info(_StateIdT __start, size_t) : _M_start(__start)
   { }


   bool _M_visited(_StateIdT) const { return false; }
   void _M_queue(_StateIdT, const _ResultsVec&) { }

   _BiIter* _M_get_sol_pos() { return &_M_sol_pos; }


   _StateIdT _M_start;
   _BiIter _M_sol_pos;
 };

    public:
      _ResultsVec _M_cur_results;
      _BiIter _M_current;
      _BiIter _M_begin;
      const _BiIter _M_end;
      const _RegexT& _M_re;
      const _NFAT& _M_nfa;
      _ResultsVec& _M_results;
      std::vector<pair<_BiIter, int>> _M_rep_count;
      _State_info<__search_mode, _ResultsVec> _M_states;
      _FlagT _M_flags;

      bool _M_has_sol;
    };


}

}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.tcc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{
  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_search()
    {
      if (_M_search_from_first())
 return true;
      if (_M_flags & regex_constants::match_continuous)
 return false;
      _M_flags |= regex_constants::match_prev_avail;
      while (_M_begin != _M_end)
 {
   ++_M_begin;
   if (_M_search_from_first())
     return true;
 }
      return false;
    }
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.tcc" 3
  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_main_dispatch(_Match_mode __match_mode, __dfs)
    {
      _M_has_sol = false;
      *_M_states._M_get_sol_pos() = _BiIter();
      _M_cur_results = _M_results;
      _M_dfs(__match_mode, _M_states._M_start);
      return _M_has_sol;
    }
# 113 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.tcc" 3
  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_main_dispatch(_Match_mode __match_mode, __bfs)
    {
      _M_states._M_queue(_M_states._M_start, _M_results);
      bool __ret = false;
      while (1)
 {
   _M_has_sol = false;
   if (_M_states._M_match_queue.empty())
     break;
   std::fill_n(_M_states._M_visited_states, _M_nfa.size(), false);
   auto __old_queue = std::move(_M_states._M_match_queue);
   auto __alloc = _M_cur_results.get_allocator();
   for (auto& __task : __old_queue)
     {
       _M_cur_results = _ResultsVec(std::move(__task.second), __alloc);
       _M_dfs(__match_mode, __task.first);
     }
   if (__match_mode == _Match_mode::_Prefix)
     __ret |= _M_has_sol;
   if (_M_current == _M_end)
     break;
   ++_M_current;
 }
      if (__match_mode == _Match_mode::_Exact)
 __ret = _M_has_sol;
      _M_states._M_match_queue.clear();
      return __ret;
    }


  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_lookahead(_StateIdT __next)
    {



      _ResultsVec __what(_M_cur_results);
      _Executor __sub(_M_current, _M_end, __what, _M_re, _M_flags);
      __sub._M_states._M_start = __next;
      if (__sub._M_search_from_first())
 {
   for (size_t __i = 0; __i < __what.size(); __i++)
     if (__what[__i].matched)
       _M_cur_results[__i] = __what[__i];
   return true;
 }
      return false;
    }







  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_rep_once_more(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];
      auto& __rep_count = _M_rep_count[__i];
      if (__rep_count.second == 0 || __rep_count.first != _M_current)
 {
   auto __back = __rep_count;
   __rep_count.first = _M_current;
   __rep_count.second = 1;
   _M_dfs(__match_mode, __state._M_alt);
   __rep_count = __back;
 }
      else
 {
   if (__rep_count.second < 2)
     {
       __rep_count.second++;
       _M_dfs(__match_mode, __state._M_alt);
       __rep_count.second--;
     }
 }
    }





  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];


      if (!__state._M_neg)
 {
   _M_rep_once_more(__match_mode, __i);

   if (!__dfs_mode || !_M_has_sol)
     _M_dfs(__match_mode, __state._M_next);
 }
      else
 {
   if (__dfs_mode)
     {

       _M_dfs(__match_mode, __state._M_next);
       if (!_M_has_sol)
  _M_rep_once_more(__match_mode, __i);
     }
   else
     {



       if (!_M_has_sol)
  {
    _M_dfs(__match_mode, __state._M_next);



    if (!_M_has_sol)
      _M_rep_once_more(__match_mode, __i);
  }
     }
 }
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_subexpr_begin(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];

      auto& __res = _M_cur_results[__state._M_subexpr];
      auto __back = __res.first;
      __res.first = _M_current;
      _M_dfs(__match_mode, __state._M_next);
      __res.first = __back;
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];

      auto& __res = _M_cur_results[__state._M_subexpr];
      auto __back = __res;
      __res.second = _M_current;
      __res.matched = true;
      _M_dfs(__match_mode, __state._M_next);
      __res = __back;
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_line_begin_assertion(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];
      if (_M_at_begin())
 _M_dfs(__match_mode, __state._M_next);
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_line_end_assertion(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];
      if (_M_at_end())
 _M_dfs(__match_mode, __state._M_next);
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_word_boundary(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];
      if (_M_word_boundary() == !__state._M_neg)
 _M_dfs(__match_mode, __state._M_next);
    }



  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];
      if (_M_lookahead(__state._M_alt) == !__state._M_neg)
 _M_dfs(__match_mode, __state._M_next);
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_match(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];

      if (_M_current == _M_end)
 return;
      if (__dfs_mode)
 {
   if (__state._M_matches(*_M_current))
     {
       ++_M_current;
       _M_dfs(__match_mode, __state._M_next);
       --_M_current;
     }
 }
      else
 if (__state._M_matches(*_M_current))
   _M_states._M_queue(__state._M_next, _M_cur_results);
    }

  template<typename _BiIter, typename _TraitsT>
    struct _Backref_matcher
    {
      _Backref_matcher(bool , const _TraitsT& __traits)
      : _M_traits(__traits) { }

      bool
      _M_apply(_BiIter __expected_begin,
        _BiIter __expected_end, _BiIter __actual_begin,
        _BiIter __actual_end)
      {
 return _M_traits.transform(__expected_begin, __expected_end)
     == _M_traits.transform(__actual_begin, __actual_end);
      }

      const _TraitsT& _M_traits;
    };

  template<typename _BiIter, typename _CharT>
    struct _Backref_matcher<_BiIter, std::regex_traits<_CharT>>
    {
      using _TraitsT = std::regex_traits<_CharT>;
      _Backref_matcher(bool __icase, const _TraitsT& __traits)
      : _M_icase(__icase), _M_traits(__traits) { }

      bool
      _M_apply(_BiIter __expected_begin,
        _BiIter __expected_end, _BiIter __actual_begin,
        _BiIter __actual_end)
      {
 if (!_M_icase)
   return std::__equal4(__expected_begin, __expected_end,
          __actual_begin, __actual_end);
 typedef std::ctype<_CharT> __ctype_type;
 const auto& __fctyp = use_facet<__ctype_type>(_M_traits.getloc());
 return std::__equal4(__expected_begin, __expected_end,
        __actual_begin, __actual_end,
        [this, &__fctyp](_CharT __lhs, _CharT __rhs)
        {
          return __fctyp.tolower(__lhs)
     == __fctyp.tolower(__rhs);
        });
      }

      bool _M_icase;
      const _TraitsT& _M_traits;
    };





  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_backref(_Match_mode __match_mode, _StateIdT __i)
    {
      do { if (std::__is_constant_evaluated() && !bool(__dfs_mode)) std::__glibcxx_assert_fail(); } while (false);

      const auto& __state = _M_nfa[__i];
      auto& __submatch = _M_cur_results[__state._M_backref_index];
      if (!__submatch.matched)
 return;
      auto __last = _M_current;
      for (auto __tmp = __submatch.first;
    __last != _M_end && __tmp != __submatch.second;
    ++__tmp)
 ++__last;
      if (_Backref_matcher<_BiIter, _TraitsT>(
       _M_re.flags() & regex_constants::icase,
       _M_re._M_automaton->_M_traits)._M_apply(
    __submatch.first, __submatch.second, _M_current, __last))
 {
   if (__last != _M_current)
     {
       auto __backup = _M_current;
       _M_current = __last;
       _M_dfs(__match_mode, __state._M_next);
       _M_current = __backup;
     }
   else
     _M_dfs(__match_mode, __state._M_next);
 }
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_accept(_Match_mode __match_mode, _StateIdT)
    {
      if constexpr (__dfs_mode)
 {
   do { if (std::__is_constant_evaluated() && !bool(!_M_has_sol)) std::__glibcxx_assert_fail(); } while (false);
   if (__match_mode == _Match_mode::_Exact)
     _M_has_sol = _M_current == _M_end;
   else
     _M_has_sol = true;
   if (_M_current == _M_begin
       && (_M_flags & regex_constants::match_not_null))
     _M_has_sol = false;
   if (_M_has_sol)
     {
       if (_M_nfa._M_flags & regex_constants::ECMAScript)
  _M_results = _M_cur_results;
       else
  {
    do { if (std::__is_constant_evaluated() && !bool(_M_states._M_get_sol_pos())) std::__glibcxx_assert_fail(); } while (false);







    if (*_M_states._M_get_sol_pos() == _BiIter()
        || std::distance(_M_begin,
           *_M_states._M_get_sol_pos())
    < std::distance(_M_begin, _M_current))
      {
        *_M_states._M_get_sol_pos() = _M_current;
        _M_results = _M_cur_results;
      }
  }
     }
 }
      else
 {
   if (_M_current == _M_begin
       && (_M_flags & regex_constants::match_not_null))
     return;
   if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end)
     if (!_M_has_sol)
       {
  _M_has_sol = true;
  _M_results = _M_cur_results;
       }
 }
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
    {
      const auto& __state = _M_nfa[__i];

      if (_M_nfa._M_flags & regex_constants::ECMAScript)
 {

   _M_dfs(__match_mode, __state._M_alt);

   if (!_M_has_sol)
     _M_dfs(__match_mode, __state._M_next);
 }
      else
 {


   _M_dfs(__match_mode, __state._M_alt);
   auto __has_sol = _M_has_sol;
   _M_has_sol = false;
   _M_dfs(__match_mode, __state._M_next);
   _M_has_sol |= __has_sol;
 }
    }

  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_dfs(_Match_mode __match_mode, _StateIdT __i)
    {
      if (_M_states._M_visited(__i))
 return;

      switch (_M_nfa[__i]._M_opcode())
 {
 case _S_opcode_repeat:
   _M_handle_repeat(__match_mode, __i); break;
 case _S_opcode_subexpr_begin:
   _M_handle_subexpr_begin(__match_mode, __i); break;
 case _S_opcode_subexpr_end:
   _M_handle_subexpr_end(__match_mode, __i); break;
 case _S_opcode_line_begin_assertion:
   _M_handle_line_begin_assertion(__match_mode, __i); break;
 case _S_opcode_line_end_assertion:
   _M_handle_line_end_assertion(__match_mode, __i); break;
 case _S_opcode_word_boundary:
   _M_handle_word_boundary(__match_mode, __i); break;
 case _S_opcode_subexpr_lookahead:
   _M_handle_subexpr_lookahead(__match_mode, __i); break;
 case _S_opcode_match:
   _M_handle_match(__match_mode, __i); break;
 case _S_opcode_backref:
   _M_handle_backref(__match_mode, __i); break;
 case _S_opcode_accept:
   _M_handle_accept(__match_mode, __i); break;
 case _S_opcode_alternative:
   _M_handle_alternative(__match_mode, __i); break;
 default:
   do { if (std::__is_constant_evaluated() && !bool(false)) std::__glibcxx_assert_fail(); } while (false);
 }
    }


  template<typename _BiIter, typename _Alloc, typename _TraitsT,
    bool __dfs_mode>
    bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
    _M_word_boundary() const
    {
      if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow))
 return false;
      if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow))
 return false;

      bool __left_is_word = false;
      if (_M_current != _M_begin
   || (_M_flags & regex_constants::match_prev_avail))
 {
   auto __prev = _M_current;
   if (_M_is_word(*std::prev(__prev)))
     __left_is_word = true;
 }
      bool __right_is_word =
        _M_current != _M_end && _M_is_word(*_M_current);

      return __left_is_word != __right_is_word;
    }
}


}
# 313 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/regex_executor.h" 2 3
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/regex" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _BidirectionalIterator>
      using match_results
 = std::match_results<_BidirectionalIterator, polymorphic_allocator<
    sub_match<_BidirectionalIterator>>>;
    using cmatch = match_results<const char*>;


    using smatch
      = match_results<__gnu_cxx::__normal_iterator<const char*, string>>;

    using wcmatch = match_results<const wchar_t*>;
    using wsmatch
      = match_results<__gnu_cxx::__normal_iterator<const wchar_t*, wstring>>;

  }

}
# 20 "include/framework/datastore/DataStore.h" 2





class TObject;
class TClass;

namespace Belle2 {
  class StoreAccessorBase;
  class DependencyMap;
  class RelationVectorBase;
  template <class T> class RelationVector;
  struct RelationEntry;
# 47 "include/framework/datastore/DataStore.h"
  class DataStore {
  public:





    enum EDurability {
      c_Event,
      c_Persistent
    };

    const static int c_NDurabilityTypes = 2;





    enum EStoreFlags {
      c_WriteOut = 0,
      c_DontWriteOut = 1,
      c_ErrorIfAlreadyRegistered = 2,
    };


    enum ESearchSide {
      c_FromSide,
      c_ToSide,
      c_BothSides
    };



    typedef Belle2::StoreEntry StoreEntry;


    typedef std::map<std::string, StoreEntry> StoreEntryMap;
    typedef StoreEntryMap::iterator StoreEntryIter;
    typedef StoreEntryMap::const_iterator StoreEntryConstIter;
    typedef std::array<StoreEntryMap, c_NDurabilityTypes> DataStoreContents;
# 96 "include/framework/datastore/DataStore.h"
    static bool s_DoCleanup;







    static DataStore& Instance();





    static TClass* getTClassFromDefaultObjectName(const std::string& objectName);



    static TClass* getTClassFromDefaultArrayName(const std::string& arrayName);


    static std::string defaultObjectName(const std::string& classname);


    static std::string defaultObjectName(const TClass* t);


    template<class T> static std::string defaultObjectName()
    {
      const static std::string s = defaultObjectName(T::Class_Name());
      return s;
    }


    static std::string objectName(const TClass* t, const std::string& name);


    template<class T> static std::string objectName(const std::string& name)
    {
      return ((name.empty()) ? defaultObjectName<T>() : name);
    }


    static std::string defaultArrayName(const std::string& classname)
    {
      const std::string& objName = defaultObjectName(classname);
      std::string s;
      s.reserve(objName.length() + 1);
      s += objName;
      s += 's';
      return s;
    }


    static std::string defaultArrayName(const TClass* t);


    template<class T> static std::string defaultArrayName()
    {
      const static std::string s = defaultArrayName(defaultObjectName<T>());
      return s;
    }


    static std::string arrayName(const TClass* t, const std::string& name);


    template<class T> static std::string arrayName(const std::string& name)
    {
      return ((name.empty()) ? defaultArrayName<T>() : name);
    }


    template<class FROM, class TO> static std::string defaultRelationName()
    {
      const static std::string s = relationName(defaultArrayName<FROM>(), defaultArrayName<TO>());
      return s;
    }


    static std::string relationName(const std::string& fromName, const std::string& toName,
                                    std::string const& namedRelation = "")
    {
      std::string s;
      s.reserve(fromName.length() + toName.length() + 2);
      s += fromName;
      s += "To";
      s += toName;
      if (namedRelation.length() > 0) {
        s += "Named";


        s += namedRelation;
      }
      return s;
    }
# 208 "include/framework/datastore/DataStore.h"
    bool registerEntry(const std::string& name, EDurability durability,
                       TClass* objClass, bool array, EStoreFlags storeFlags);
# 222 "include/framework/datastore/DataStore.h"
    bool registerRelation(const StoreAccessorBase& fromArray, const StoreAccessorBase& toArray, EDurability durability,
                          EStoreFlags storeFlags, const std::string& namedRelation);
# 234 "include/framework/datastore/DataStore.h"
    bool hasRelation(const StoreAccessorBase& fromArray, const StoreAccessorBase& toArray, EDurability durability,
                     const std::string& namedRelation);
# 244 "include/framework/datastore/DataStore.h"
    bool requireInput(const StoreAccessorBase& accessor);
# 256 "include/framework/datastore/DataStore.h"
    bool requireRelation(const StoreAccessorBase& fromArray, const StoreAccessorBase& toArray, EDurability durability,
                         std::string const& namedRelation);
# 267 "include/framework/datastore/DataStore.h"
    bool optionalInput(const StoreAccessorBase& accessor);
# 279 "include/framework/datastore/DataStore.h"
    static bool optionalRelation(const StoreAccessorBase& fromArray, const StoreAccessorBase& toArray, EDurability durability,
                                 std::string const& namedRelation);
# 290 "include/framework/datastore/DataStore.h"
    StoreEntry* getEntry(const StoreAccessorBase& accessor);
# 299 "include/framework/datastore/DataStore.h"
    TObject** getObject(const StoreAccessorBase& accessor);
# 309 "include/framework/datastore/DataStore.h"
    bool createObject(TObject* object, bool replace, const StoreAccessorBase& accessor);





    void replaceData(const StoreAccessorBase& from, const StoreAccessorBase& to);





    StoreEntryMap& getStoreEntryMap(EDurability durability) { return m_storeEntryMap[durability]; }
# 335 "include/framework/datastore/DataStore.h"
    void addRelation(const TObject* fromObject, StoreEntry*& fromEntry, int& fromIndex, const TObject* toObject, StoreEntry*& toEntry,
                     int& toIndex, float weight, const std::string& namedRelation);
# 353 "include/framework/datastore/DataStore.h"
    RelationVectorBase getRelationsWith(ESearchSide searchSide, const TObject* object, StoreEntry*& entry, int& index,
                                        const TClass* withClass, const std::string& withName, const std::string& namedRelation);
# 370 "include/framework/datastore/DataStore.h"
    Belle2::RelationEntry getRelationWith(ESearchSide searchSide, const TObject* object, StoreEntry*& entry, int& index,
                                          const TClass* withClass, const std::string& withName, const std::string& namedRelation);
# 383 "include/framework/datastore/DataStore.h"
    static void addRelationFromTo(const TObject* fromObject, const TObject* toObject, float weight = 1.0,
                                  const std::string& namedRelation = "")
    {
      DataStore::StoreEntry* fromEntry = nullptr;
      int fromIndex = -1;
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      Instance().addRelation(fromObject, fromEntry, fromIndex, toObject, toEntry, toIndex, weight, namedRelation);
    }
# 408 "include/framework/datastore/DataStore.h"
    template <class T> static RelationVector<T> getRelationsWithObj(const TObject* object, const std::string& name = "",
        const std::string& namedRelation = "")
    {
      StoreEntry* storeEntry = nullptr;
      int index = -1;
      return RelationVector<T>(Instance().getRelationsWith(c_BothSides, object, storeEntry, index, T::Class(), name, namedRelation));
    }
# 428 "include/framework/datastore/DataStore.h"
    template <class T> static T* getRelated(const TObject* object, const std::string& name = "", const std::string& namedRelation = "")
    {
      if (!object) return nullptr;
      StoreEntry* storeEntry = nullptr;
      int index = -1;
      return static_cast<T*>(DataStore::Instance().getRelationWith(c_BothSides, object, storeEntry, index, T::Class(), name,
                             namedRelation).object);
    }
# 464 "include/framework/datastore/DataStore.h"
    bool findStoreEntry(const TObject* object, StoreEntry*& entry, int& index);





    std::vector<std::string> getListOfRelatedArrays(const StoreAccessorBase& array) const;


    std::vector<std::string> getListOfArrays(const TClass* arrayClass, EDurability durability) const;





    static std::vector<std::string> getListOfObjects(const TClass* objClass, EDurability durability);



    static std::vector<std::string> getListOfRelations(EDurability durability);



    std::vector<std::string> getSortedListOfDataStore(EDurability durability) const;







    void setInitializeActive(bool active);


    bool getInitializeActive() const { return m_initializeActive; }





    void invalidateData(EDurability durability);






    void reset(EDurability durability);





    void reset();


    DependencyMap& getDependencyMap() { return *m_dependencyMap; }



    void createNewDataStoreID(const std::string& id);

    void createEmptyDataStoreID(const std::string& id);

    std::string currentID() const;

    void switchID(const std::string& id);

    void copyEntriesTo(const std::string& id, const std::vector<std::string>& entrylist_event = {}, bool mergeEntries = false);

    void copyContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});

    void mergeContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});

  private:

    explicit DataStore();

    DataStore(const DataStore&) = delete;

    DataStore& operator=(const DataStore&) = delete;

    ~DataStore();
# 556 "include/framework/datastore/DataStore.h"
    static bool checkType(const StoreEntry& entry, const StoreAccessorBase& accessor);







    const std::vector<std::string>& getArrayNames(const std::string& arrayName, const TClass* arrayClass,
                                                  EDurability durability = c_Event) const;





    static void updateRelationsObjectCache(StoreEntry& entry);





    class SwitchableDataStoreContents {
    public:
      SwitchableDataStoreContents();

      void clear();

      void reset(EDurability durability);

      void invalidateData(EDurability durability);

      const StoreEntryMap& operator [](int durability) const { return m_entries[m_currentIdx][durability]; }

      StoreEntryMap& operator [](int durability)
      {

        const SwitchableDataStoreContents* this2 = this;
        return const_cast<StoreEntryMap&>((*this2)[durability]);
      }


      void switchID(const std::string& id);

      const std::string& currentID() const { return m_currentID; }

      void copyEntriesTo(const std::string& id, const std::vector<std::string>& entrylist_event = {}, bool mergeEntries = false);

      void copyContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});

      void mergeContentsTo(const std::string& id, const std::vector<std::string>& entrylist_event = {});

      void createNewDataStoreID(const std::string& id);

      void createEmptyDataStoreID(const std::string& id);
    private:
      std::vector<DataStoreContents> m_entries;
      std::map<std::string, int> m_idToIndexMap;
      std::string m_currentID = "";
      int m_currentIdx = 0;
    };

    SwitchableDataStoreContents m_storeEntryMap;






    bool m_initializeActive;





    const std::regex m_regexNamedRelationCheck = std::regex("^[a-zA-Z]*$");


    DependencyMap* m_dependencyMap;
  };

  inline DataStore::EStoreFlags operator| (DataStore::EStoreFlags x , DataStore::EStoreFlags y ) { return static_cast<DataStore::EStoreFlags>( static_cast<int>(x) | static_cast<int>(y)); } inline DataStore::EStoreFlags operator& (DataStore::EStoreFlags x , DataStore::EStoreFlags y ) { return static_cast<DataStore::EStoreFlags>( static_cast<int>(x) & static_cast<int>(y)); } inline DataStore::EStoreFlags operator^ (DataStore::EStoreFlags x , DataStore::EStoreFlags y ) { return static_cast<DataStore::EStoreFlags>( static_cast<int>(x) ^ static_cast<int>(y)); } inline DataStore::EStoreFlags operator~ (DataStore::EStoreFlags x ) { return static_cast<DataStore::EStoreFlags>(~static_cast<int>(x)); } inline DataStore::EStoreFlags & operator&=(DataStore::EStoreFlags & x , DataStore::EStoreFlags y) { x = x & y ; return x ; } inline DataStore::EStoreFlags & operator|=(DataStore::EStoreFlags & x , DataStore::EStoreFlags y) { x = x | y ; return x ; } inline DataStore::EStoreFlags & operator^=(DataStore::EStoreFlags & x , DataStore::EStoreFlags y) { x = x ^ y ; return x ; };
}
# 12 "include/framework/database/DBStore.h" 2
# 1 "include/framework/datastore/StoreObjPtr.h" 1
# 12 "include/framework/datastore/StoreObjPtr.h"
# 1 "include/framework/datastore/StoreAccessorBase.h" 1
# 15 "include/framework/datastore/StoreAccessorBase.h"
class TClass;

namespace Belle2 {

  typedef std::pair<std::string, DataStore::EDurability>
  AccessorParams;


  class StoreAccessorBase {
  public:
# 33 "include/framework/datastore/StoreAccessorBase.h"
    StoreAccessorBase(const std::string& name, DataStore::EDurability durability, TClass* objClass, bool isArray):
      m_name(name), m_durability(durability), m_class(objClass), m_isArray(isArray) {}





    virtual ~StoreAccessorBase() {}







    bool registerInDataStore(DataStore::EStoreFlags storeFlags = DataStore::c_WriteOut)
    {
      return DataStore::Instance().registerEntry(m_name, m_durability, getClass(), isArray(), storeFlags);
    }
# 60 "include/framework/datastore/StoreAccessorBase.h"
    bool registerInDataStore(const std::string& name, DataStore::EStoreFlags storeFlags = DataStore::c_WriteOut)
    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().registerEntry(m_name, m_durability, getClass(), isArray(), storeFlags);
    }
# 74 "include/framework/datastore/StoreAccessorBase.h"
    bool isRequired(const std::string& name = "")
    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().requireInput(*this);
    }
# 89 "include/framework/datastore/StoreAccessorBase.h"
    bool isOptional(const std::string& name = "")
    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().optionalInput(*this);
    }
# 103 "include/framework/datastore/StoreAccessorBase.h"
    bool create(bool replace = false)
    {
      return DataStore::Instance().createObject(0, replace, *this);
    }







    bool assign(TObject* object, bool replace = false);


    virtual void clear()
    {
      create(true);
    }



    const std::string& getName() const { return m_name; }


    DataStore::EDurability getDurability() const { return m_durability; }


    AccessorParams getAccessorParams() const { return make_pair(m_name, m_durability);}


    virtual bool operator==(const StoreAccessorBase& other) const
    {
      return getAccessorParams() == other.getAccessorParams();
    }


    virtual bool operator!=(const StoreAccessorBase& other) const
    {
      return !(*this == other);
    }


    TClass* getClass() const { return m_class; }


    bool isArray() const { return m_isArray; }


    bool notWrittenOut() const;






    std::string readableName() const;

  protected:

    std::string m_name;


    DataStore::EDurability m_durability;


    TClass* m_class;


    bool m_isArray;

  };
}
# 13 "include/framework/datastore/StoreObjPtr.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 2 3
# 15 "include/framework/datastore/StoreObjPtr.h" 2


namespace Belle2 {
# 92 "include/framework/datastore/StoreObjPtr.h"
  template <class T> class StoreObjPtr : public StoreAccessorBase {
  public:






    explicit StoreObjPtr(const std::string& name = "", DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(DataStore::objectName<T>(name), durability, T::Class(), false), m_storeObjPtr(0) {}





    inline bool isValid() const {ensureAttached(); return m_storeObjPtr && *m_storeObjPtr;}







    template<class ...Args> bool construct(Args&& ... params)
    {
      T* t = new T(std::forward<Args>(params)...);
      return assign(t, false);
    }







    template<class ...Args> bool constructAndReplace(Args&& ... params)
    {
      T* t = new T(std::forward<Args>(params)...);
      return assign(t, true);
    }


    inline T& operator *() const {return *operator->();}



    inline T* operator ->() const {ensureValid(); return static_cast<T*>(*m_storeObjPtr);}

    inline operator bool() const {return isValid();}



    static std::vector<std::string> getObjectList(DataStore::EDurability durability = DataStore::c_Event)
    {
      return DataStore::Instance().getListOfObjects(T::Class(), durability);
    }

  private:

    inline void ensureAttached() const
    {
      if (!m_storeObjPtr) {
        const_cast<StoreObjPtr*>(this)->m_storeObjPtr = DataStore::Instance().getObject(*this);
      }
    }

    inline void ensureValid() const
    {
      ensureAttached();
      if (!m_storeObjPtr || !(*m_storeObjPtr))
        throw std::runtime_error("Trying to access StoreObjPtr " + readableName() +
                                 ", which was not created. Please check isValid() before accesses if the object is not guaranteed to be created in every event.");
    }

    TObject** m_storeObjPtr;
  };
}
# 13 "include/framework/database/DBStore.h" 2
# 1 "include/framework/dataobjects/EventMetaData.h" 1
# 15 "include/framework/dataobjects/EventMetaData.h"
namespace Belle2 {
# 29 "include/framework/dataobjects/EventMetaData.h"
  class EventMetaData : public TObject {
  public:


    explicit EventMetaData(unsigned int event = 1, int run = 0, int experiment = 0);


    ~EventMetaData() {}


    enum EventErrorFlag {
      c_B2LinkPacketCRCError = 0x1,
      c_B2LinkEventCRCError = 0x2,
      c_HLTCrash = 0x4,
      c_HLTPrefilterDiscard = 0x8,
      c_HLTDiscard = 0x10,
    };





    void setEvent(unsigned int event) { m_event = event; }





    void setRun(int run) { m_run = run; }





    void setSubrun(int subrun) { m_subrun = subrun; }





    void setExperiment(int experiment) { m_experiment = experiment; }





    void setProduction(int production) { m_production = production; }





    void setTime(unsigned long long int time) { m_time = time; }
# 93 "include/framework/dataobjects/EventMetaData.h"
    void setEndOfData();





    void setEndOfRun(unsigned int experimentNumber, unsigned int runNumber);


    bool isEndOfData() const;


    bool isEndOfRun() const;





    void setParentLfn(const std::string& parent) { m_parentLfn = parent; }





    void setGeneratedWeight(double weight) { m_generatedWeight = weight; }





    void setErrorFlag(unsigned int errorFlag) { m_errorFlag = errorFlag; }





    void addErrorFlag(EventErrorFlag errorFlag) { m_errorFlag |= errorFlag; }





    unsigned int getErrorFlag() const { return m_errorFlag; }





    unsigned int getEvent() const { return m_event; }





    int getRun() const { return m_run; }






    int getSubrun() const { return m_subrun; }





    int getExperiment() const { return m_experiment; }





    int getProduction() const { return m_production; }





    unsigned long long int getTime() const { return m_time; }



    const std::string& getParentLfn() const { return m_parentLfn; }





    double getGeneratedWeight() const { return m_generatedWeight; }






    bool operator== (const EventMetaData& eventMetaData) const;






    bool operator!= (const EventMetaData& eventMetaData) const { return !(*this == eventMetaData); }


  private:
    unsigned int m_event;
    int m_run;
    int m_subrun;
    int m_experiment;

    int m_production;
    unsigned long long int m_time;
    std::string m_parentLfn;
    double m_generatedWeight;
    unsigned int m_errorFlag;

    private: static_assert(std::is_integral<decltype(4)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("EventMetaData") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 4; } virtual TClass *IsA() const { return EventMetaData::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(EventMetaData::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { EventMetaData::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/dataobjects/EventMetaData.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 211; };
  };
}
# 14 "include/framework/database/DBStore.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 2 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    class optional;


  struct nullopt_t
  {





    enum class _Construct { _Token };


    explicit constexpr nullopt_t(_Construct) noexcept { }
  };


  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

  template<typename _Fn> struct _Optional_func { _Fn& _M_f; };






  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() = default;
    virtual ~bad_optional_access() = default;

    const char* what() const noexcept override
    { return "bad optional access"; }
  };


  [[__noreturn__]] inline void
  __throw_bad_optional_access()
  { (throw (bad_optional_access())); }



  template <typename _Tp>
    struct _Optional_payload_base
    {
      using _Stored_type = remove_const_t<_Tp>;

      _Optional_payload_base() = default;
      ~_Optional_payload_base() = default;

      template<typename... _Args>
 constexpr
 _Optional_payload_base(in_place_t __tag, _Args&&... __args)
 : _M_payload(__tag, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }

      template<typename _Up, typename... _Args>
 constexpr
 _Optional_payload_base(std::initializer_list<_Up> __il,
          _Args&&... __args)
 : _M_payload(__il, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }



      constexpr
      _Optional_payload_base(bool ,
        const _Optional_payload_base& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(__other._M_get());
      }



      constexpr
      _Optional_payload_base(bool ,
        _Optional_payload_base&& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(std::move(__other._M_get()));
      }



      _Optional_payload_base(const _Optional_payload_base&) = default;



      _Optional_payload_base(_Optional_payload_base&&) = default;

      _Optional_payload_base&
      operator=(const _Optional_payload_base&) = default;

      _Optional_payload_base&
      operator=(_Optional_payload_base&&) = default;


      constexpr void
      _M_copy_assign(const _Optional_payload_base& __other)
      {
 if (this->_M_engaged && __other._M_engaged)
   this->_M_get() = __other._M_get();
 else
   {
     if (__other._M_engaged)
       this->_M_construct(__other._M_get());
     else
       this->_M_reset();
   }
      }


      constexpr void
      _M_move_assign(_Optional_payload_base&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 if (this->_M_engaged && __other._M_engaged)
   this->_M_get() = std::move(__other._M_get());
 else
   {
     if (__other._M_engaged)
       this->_M_construct(std::move(__other._M_get()));
     else
       this->_M_reset();
   }
      }

      struct _Empty_byte { };

      template<typename _Up, bool = is_trivially_destructible_v<_Up>>
 union _Storage
 {
   constexpr _Storage() noexcept : _M_empty() { }

   template<typename... _Args>
     constexpr
     _Storage(in_place_t, _Args&&... __args)
     : _M_value(std::forward<_Args>(__args)...)
     { }

   template<typename _Vp, typename... _Args>
     constexpr
     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
     : _M_value(__il, std::forward<_Args>(__args)...)
     { }


   template<typename _Fn, typename _Arg>
     constexpr
     _Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
     : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
         std::forward<_Arg>(__arg)))
     { }



   ~_Storage() = default;


   constexpr
   ~_Storage() requires (!is_trivially_destructible_v<_Up>)
   { }

   _Storage(const _Storage&) = default;
   _Storage(_Storage&&) = default;
   _Storage& operator=(const _Storage&) = default;
   _Storage& operator=(_Storage&&) = default;


   _Empty_byte _M_empty;
   _Up _M_value;
 };
# 289 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
      _Storage<_Stored_type> _M_payload;

      bool _M_engaged = false;

      template<typename... _Args>
 constexpr void
 _M_construct(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 {
   std::_Construct(std::__addressof(this->_M_payload._M_value),
     std::forward<_Args>(__args)...);
   this->_M_engaged = true;
 }

      constexpr void
      _M_destroy() noexcept
      {
 _M_engaged = false;
 _M_payload._M_value.~_Stored_type();
      }


      template<typename _Fn, typename _Up>
 constexpr void
 _M_apply(_Optional_func<_Fn> __f, _Up&& __x)
 {
   std::construct_at(std::__addressof(this->_M_payload),
       __f, std::forward<_Up>(__x));
   _M_engaged = true;
 }






      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_value; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_value; }


      constexpr void
      _M_reset() noexcept
      {
 if (this->_M_engaged)
   _M_destroy();
 else
   this->_M_engaged = false;
      }
    };


  template <typename _Tp,
     bool =
       is_trivially_destructible_v<_Tp>,
     bool =
       is_trivially_copy_assignable_v<_Tp>
       && is_trivially_copy_constructible_v<_Tp>,
     bool =
       is_trivially_move_assignable_v<_Tp>
       && is_trivially_move_constructible_v<_Tp>>
    struct _Optional_payload;


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp, bool _Copy, bool _Move>
    struct _Optional_payload<_Tp, false, _Copy, _Move>
    : _Optional_payload<_Tp, true, false, false>
    {

      using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
      _Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      constexpr ~_Optional_payload() { this->_M_reset(); }
    };
# 482 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
  template<typename _Tp,
    bool = is_trivially_copy_constructible_v<_Tp>,
    bool = is_trivially_move_constructible_v<_Tp>>
    struct _Optional_base
    {

      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)
      noexcept(is_nothrow_copy_constructible_v<_Tp>)
      : _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))
      { }




      constexpr _Optional_base(const _Optional_base&)
 requires is_trivially_copy_constructible_v<_Tp> = default;

      constexpr _Optional_base(_Optional_base&&)
 requires is_trivially_move_constructible_v<_Tp> = default;



      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;

    protected:

      using _Stored_type = remove_const_t<_Tp>;



      template<typename... _Args>
 constexpr void
 _M_construct(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 {
   _M_payload._M_construct(std::forward<_Args>(__args)...);
 }

      constexpr void
      _M_destruct() noexcept
      { _M_payload._M_destroy(); }


      constexpr void
      _M_reset() noexcept
      { _M_payload._M_reset(); }

      constexpr bool _M_is_engaged() const noexcept
      { return _M_payload._M_engaged; }


      constexpr _Tp&
      _M_get() noexcept
      { return _M_payload._M_get(); }

      constexpr const _Tp&
      _M_get() const noexcept
      { return _M_payload._M_get(); }
    };
# 746 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
  template<typename _Tp>
    inline constexpr bool __is_optional_v = false;
  template<typename _Tp>
    inline constexpr bool __is_optional_v<optional<_Tp>> = true;

  template<typename _Tp, typename _Wp>
    using __converts_from_any_cvref = __or_<
 is_constructible<_Tp, _Wp&>, is_convertible<_Wp&, _Tp>,
 is_constructible<_Tp, _Wp>, is_convertible<_Wp, _Tp>,
 is_constructible<_Tp, const _Wp&>, is_convertible<const _Wp&, _Tp>,
 is_constructible<_Tp, const _Wp>, is_convertible<const _Wp, _Tp>
      >;

  template<typename _Tp, typename _Up>
    using __converts_from_optional
      = __converts_from_any_cvref<_Tp, optional<_Up>>;

  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>&&>>;
# 777 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<

 is_copy_constructible_v<_Tp>,

 __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,

 is_move_constructible_v<_Tp>,

 __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,

 optional<_Tp>>
    {
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(is_object_v<_Tp> && !is_array_v<_Tp>);

    private:
      using _Base = _Optional_base<_Tp>;
# 806 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
      template<typename _From, typename = remove_cv_t<_Tp>>
 static constexpr bool __not_constructing_bool_from_optional
   = true;



      template<typename _From>
 static constexpr bool
 __not_constructing_bool_from_optional<_From, bool>
   = !__is_optional_v<remove_cvref_t<_From>>;





      template<typename _From, typename = remove_cv_t<_Tp>>
 static constexpr bool __construct_from_contained_value
   = !__converts_from_optional<_Tp, _From>::value;



      template<typename _From>
 static constexpr bool __construct_from_contained_value<_From, bool>
   = true;
# 859 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
    public:
      using value_type = _Tp;

      constexpr optional() noexcept { }

      constexpr optional(nullopt_t) noexcept { }



      template<typename _Up = remove_cv_t<_Tp>>
 requires (!is_same_v<optional, remove_cvref_t<_Up>>)
   && (!is_same_v<in_place_t, remove_cvref_t<_Up>>)
   && is_constructible_v<_Tp, _Up>
   && __not_constructing_bool_from_optional<_Up>
 constexpr explicit(!is_convertible_v<_Up, _Tp>)
 optional(_Up&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up>
 requires (!is_same_v<_Tp, _Up>)
   && is_constructible_v<_Tp, const _Up&>
   && __construct_from_contained_value<_Up>
 constexpr explicit(!is_convertible_v<const _Up&, _Tp>)
 optional(const optional<_Up>& __t)
 noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 {
   if (__t)
     emplace(__t._M_get());
 }

      template<typename _Up>
 requires (!is_same_v<_Tp, _Up>)
   && is_constructible_v<_Tp, _Up>
   && __construct_from_contained_value<_Up>
 constexpr explicit(!is_convertible_v<_Up, _Tp>)
 optional(optional<_Up>&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 {
   if (__t)
     emplace(std::move(__t._M_get()));
 }

      template<typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
 explicit constexpr
 optional(in_place_t, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 : _Base(std::in_place, std::forward<_Args>(__args)...)
 { }

      template<typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
 explicit constexpr
 optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
         _Args...>)
 : _Base(std::in_place, __il, std::forward<_Args>(__args)...)
 { }
# 1010 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
      constexpr optional&
      operator=(nullopt_t) noexcept
      {
 this->_M_reset();
 return *this;
      }

      template<typename _Up = remove_cv_t<_Tp>>

 requires (!is_same_v<optional, remove_cvref_t<_Up>>)
   && (!(is_scalar_v<_Tp> && is_same_v<_Tp, decay_t<_Up>>))
   && is_constructible_v<_Tp, _Up>
   && is_assignable_v<_Tp&, _Up>
 constexpr optional&
# 1032 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
 operator=(_Up&& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
    is_nothrow_assignable<_Tp&, _Up>>)
 {
   if (this->_M_is_engaged())
     this->_M_get() = std::forward<_Up>(__u);
   else
     this->_M_construct(std::forward<_Up>(__u));

   return *this;
 }

      template<typename _Up>

 requires (!is_same_v<_Tp, _Up>)
   && is_constructible_v<_Tp, const _Up&>
   && is_assignable_v<_Tp&, const _Up&>
   && (!__converts_from_optional<_Tp, _Up>::value)
   && (!__assigns_from_optional<_Tp, _Up>::value)
 constexpr optional&
# 1060 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
 operator=(const optional<_Up>& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
    is_nothrow_assignable<_Tp&, const _Up&>>)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = __u._M_get();
       else
  this->_M_construct(__u._M_get());
     }
   else
     {
       this->_M_reset();
     }
   return *this;
 }

      template<typename _Up>

 requires (!is_same_v<_Tp, _Up>)
   && is_constructible_v<_Tp, _Up>
   && is_assignable_v<_Tp&, _Up>
   && (!__converts_from_optional<_Tp, _Up>::value)
   && (!__assigns_from_optional<_Tp, _Up>::value)
 constexpr optional&
# 1094 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
 operator=(optional<_Up>&& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
    is_nothrow_assignable<_Tp&, _Up>>)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = std::move(__u._M_get());
       else
  this->_M_construct(std::move(__u._M_get()));
     }
   else
     {
       this->_M_reset();
     }

   return *this;
 }

      template<typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
 emplace(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 {
   this->_M_reset();
   this->_M_construct(std::forward<_Args>(__args)...);
   return this->_M_get();
 }

      template<typename _Up, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
      _Tp&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
         _Args...>)
 {
   this->_M_reset();
   this->_M_construct(__il, std::forward<_Args>(__args)...);
   return this->_M_get();
 }




      constexpr void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>
        && is_nothrow_swappable_v<_Tp>)
      {
 using std::swap;

 if (this->_M_is_engaged() && __other._M_is_engaged())
   swap(this->_M_get(), __other._M_get());
 else if (this->_M_is_engaged())
   {
     __other._M_construct(std::move(this->_M_get()));
     this->_M_destruct();
   }
 else if (__other._M_is_engaged())
   {
     this->_M_construct(std::move(__other._M_get()));
     __other._M_destruct();
   }
      }


      constexpr const _Tp*
      operator->() const noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return std::__addressof(this->_M_get());
      }

      constexpr _Tp*
      operator->() noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return std::__addressof(this->_M_get());
      }

      constexpr const _Tp&
      operator*() const& noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return this->_M_get();
      }

      constexpr _Tp&
      operator*()& noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return this->_M_get();
      }

      constexpr _Tp&&
      operator*()&& noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return std::move(this->_M_get());
      }

      constexpr const _Tp&&
      operator*() const&& noexcept
      {
 do { if (std::__is_constant_evaluated() && !bool(this->_M_is_engaged())) std::__glibcxx_assert_fail(); } while (false);
 return std::move(this->_M_get());
      }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
 if (this->_M_is_engaged())
   return this->_M_get();
 __throw_bad_optional_access();
      }

      constexpr _Tp&
      value()&
      {
 if (this->_M_is_engaged())
   return this->_M_get();
 __throw_bad_optional_access();
      }

      constexpr _Tp&&
      value()&&
      {
 if (this->_M_is_engaged())
   return std::move(this->_M_get());
 __throw_bad_optional_access();
      }

      constexpr const _Tp&&
      value() const&&
      {
 if (this->_M_is_engaged())
   return std::move(this->_M_get());
 __throw_bad_optional_access();
      }

      template<typename _Up = remove_cv_t<_Tp>>
 constexpr _Tp
 value_or(_Up&& __u) const&
 {
   static_assert(is_copy_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   if (this->_M_is_engaged())
     return this->_M_get();
   else
     return static_cast<_Tp>(std::forward<_Up>(__u));
 }

      template<typename _Up = remove_cv_t<_Tp>>
 constexpr _Tp
 value_or(_Up&& __u) &&
 {
   static_assert(is_move_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   if (this->_M_is_engaged())
     return std::move(this->_M_get());
   else
     return static_cast<_Tp>(std::forward<_Up>(__u));
 }
# 1402 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
      constexpr void reset() noexcept { this->_M_reset(); }

    private:
      using _Base::_M_get;

      template<typename _Up> friend class optional;
# 1417 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
    };

  template<typename _Tp>
    using __optional_relop_t =
      enable_if_t<is_convertible_v<_Tp, bool>, bool>;

  template<typename _Tp, typename _Up>
    using __optional_eq_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() == std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ne_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() != std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_lt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() < std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_gt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() > std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_le_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ge_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
      >;


  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_eq_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
      && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_ne_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
 || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_lt_t<_Tp, _Up>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_gt_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_le_t<_Tp, _Up>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_ge_t<_Tp, _Up>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }


  template<typename _Tp, three_way_comparable_with<_Tp> _Up>
    [[nodiscard]]
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y)
    {
      return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y);
    }



  template<typename _Tp>
    [[nodiscard]]
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }


  template<typename _Tp>
    [[nodiscard]]
    constexpr strong_ordering
    operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept
    { return bool(__x) <=> false; }
# 1593 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/optional" 3
  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator== [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_eq_t<_Tp, _Up>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator== [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_eq_t<_Tp, _Up>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator!= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_ne_t<_Tp, _Up>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator!= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_ne_t<_Tp, _Up>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator< [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_lt_t<_Tp, _Up>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator< [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_lt_t<_Tp, _Up>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator> [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_gt_t<_Tp, _Up>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator> [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_gt_t<_Tp, _Up>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator<= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_le_t<_Tp, _Up>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator<= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_le_t<_Tp, _Up>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
    constexpr auto
    operator>= [[nodiscard]] (const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_ge_t<_Tp, _Up>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Tp>)
    constexpr auto
    operator>= [[nodiscard]] (const _Tp& __lhs, const optional<_Up>& __rhs)
    -> __optional_ge_t<_Tp, _Up>
    { return !__rhs || __lhs >= *__rhs; }





  template<typename _Tp>
    concept __is_derived_from_optional = requires (const _Tp& __t) {
      []<typename _Up>(const optional<_Up>&){ }(__t);
    };

  template<typename _Tp, typename _Up>
    requires (!__is_derived_from_optional<_Up>)
      && requires { typename compare_three_way_result_t<_Tp, _Up>; }
      && three_way_comparable_with<_Tp, _Up>
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=> [[nodiscard]] (const optional<_Tp>& __x, const _Up& __v)
    { return bool(__x) ? *__x <=> __v : strong_ordering::less; }






  template<typename _Tp>
    constexpr
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr
    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
  optional<decay_t<_Tp>>>
    make_optional(_Tp&& __t)
    noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
    { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, _Args...>,
  optional<_Tp>>
    make_optional(_Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
    { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
  optional<_Tp>>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
    { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }



  template<typename _Tp, typename _Up = remove_const_t<_Tp>>
    struct __optional_hash

    : public __hash_empty_base<_Up>

    {





      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>
    struct hash<optional<_Tp>>
    : public __conditional_t<__is_hash_enabled_for<remove_const_t<_Tp>>,
        __optional_hash<_Tp>,
        __hash_not_enabled<_Tp>>
    { };

  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };




  template <typename _Tp> optional(_Tp) -> optional<_Tp>;





}
# 16 "include/framework/database/DBStore.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 1 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class multiset;
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
  template<typename _Key, typename _Compare = std::less<_Key>,
    typename _Alloc = std::allocator<_Key> >
    class set
    {
# 113 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 172 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)) { }
# 195 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 212 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 228 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      set(const set&) = default;







      set(set&&) = default;
# 248 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      set(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      set(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      set(const set& __x, const __type_identity_t<allocator_type>& __a)
      : _M_t(__x._M_t, _Key_alloc_type(__a)) { }


      set(set&& __x, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { }


      set(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 305 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      ~set() = default;
# 321 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      set&
      operator=(const set&) = default;


      set&
      operator=(set&&) = default;
# 339 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 464 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      void
      swap(set& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 484 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...); }
# 510 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...);
 }
# 532 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
      }
# 569 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 588 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 601 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }
# 630 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 698 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 729 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 750 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 778 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 793 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 813 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_t._M_find_tr(__x), void(), true)
 { return _M_t._M_find_tr(__x) != _M_t.end(); }
# 839 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)}; }
# 874 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 904 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(const_iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 943 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);


      template<typename _K1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<_K1>
 operator<=>(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);





    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<typename iterator_traits<_InputIterator>::value_type,
   _Compare, _Allocator>;

  template<typename _Key, typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator, _Allocator)
    -> set<typename iterator_traits<_InputIterator>::value_type,
    less<typename iterator_traits<_InputIterator>::value_type>,
    _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>, _Allocator)
    -> set<_Key, less<_Key>, _Allocator>;
# 1040 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 1061 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<_Key>
    operator<=>(const set<_Key, _Compare, _Alloc>& __x,
  const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::set<_Val, _Cmp1, _Alloc>, _Cmp2>
    {
    private:
      friend class std::set<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };



}
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class set;
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
  template <typename _Key, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<_Key> >
    class multiset
    {
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 168 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)) { }
# 190 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 206 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 222 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      multiset(const multiset&) = default;
# 231 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      multiset(multiset&&) = default;
# 243 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      multiset(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multiset(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      multiset(const multiset& __m,
        const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Key_alloc_type(__a)) { }


      multiset(multiset&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { }


      multiset(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      ~multiset() = default;
# 317 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset&) = default;


      multiset&
      operator=(multiset&&) = default;
# 335 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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(); }
# 460 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      void
      swap(multiset& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 479 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 505 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)...);
 }
# 525 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 555 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 573 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 586 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }
# 612 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated() && !bool(__pos != end())) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      iterator
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 680 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 711 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 732 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 760 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 772 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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); }
# 791 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_t._M_find_tr(__x), void(), true)
 { return _M_t._M_find_tr(__x) != _M_t.end(); }
# 817 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)}; }
# 852 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 882 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)); }
# 921 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);


      template<typename _K1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<_K1>
 operator<=>(const multiset<_K1, _C1, _A1>&,
      const multiset<_K1, _C1, _A1>&);






    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
  _Compare, _Allocator>;

  template<typename _Key,
    typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator, _Allocator)
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
         less<typename iterator_traits<_InputIterator>::value_type>,
         _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>, _Allocator)
    -> multiset<_Key, less<_Key>, _Allocator>;
# 1023 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; }
# 1044 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<_Key>
    operator<=>(const multiset<_Key, _Compare, _Alloc>& __x,
  const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1097 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(multiset<_Key, _Compare, _Alloc>& __x,
  multiset<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multiset<_Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multiset<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };



}
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 2 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/set" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using set = std::set<_Key, _Cmp, polymorphic_allocator<_Key>>;
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using multiset = std::multiset<_Key, _Cmp, polymorphic_allocator<_Key>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename set<_Key, _Compare, _Alloc>::size_type
    erase_if(set<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::set<_Key, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename multiset<_Key, _Compare, _Alloc>::size_type
    erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::multiset<_Key, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 17 "include/framework/database/DBStore.h" 2



namespace Belle2 {






  class DBStore {
  public:






    static DBStore& Instance();




    template<class T> static std::string objectName(const std::string& name) { return DataStore::objectName<T>(name); }





    template<class T> static std::string arrayName(const std::string& name) { return DataStore::arrayName<T>(name); }


    ~DBStore();
# 66 "include/framework/database/DBStore.h"
    DBStoreEntry* getEntry(DBStoreEntry::EPayloadType payloadType, const std::string& name,
                           const TClass* objClass, bool array, bool required = true);
# 82 "include/framework/database/DBStore.h"
    DBStoreEntry* getEntry(const std::string& name, const TClass* objClass,
                           bool array, bool required = true)
    {
      return getEntry(DBStoreEntry::c_Object, name, objClass, array, required);
    }





    void update();






    void update(const EventMetaData& event);





    void updateEvent();







    void updateEvent(const unsigned int eventNumber);
# 122 "include/framework/database/DBStore.h"
    void reset(bool keepEntries = false);






    std::set<std::string> getAllEntryNames();
# 143 "include/framework/database/DBStore.h"
    void addConstantOverride(const std::string& name, TObject* obj, bool oneRun = false);

  private:

    explicit DBStore() {};


    DBStore(const DBStore&);


    void performUpdate(const EventMetaData& event);





    void performUpdateEvent(const EventMetaData& event);


    std::unordered_map<std::string, DBStoreEntry> m_dbEntries;


    std::set<DBStoreEntry*> m_intraRunDependencies;




    StoreObjPtr<EventMetaData> m_storeEvent;






    std::optional<EventMetaData> m_manualEvent;
  };
}
# 11 "include/framework/database/DBAccessorBase.h" 2






class TClass;

namespace Belle2 {


  class DBAccessorBase {
  public:
# 32 "include/framework/database/DBAccessorBase.h"
    DBAccessorBase(const std::string& name, const TClass* objClass, bool isArray, bool isRequired) :
      m_type(DBStoreEntry::c_Object), m_name(name), m_objClass(objClass), m_isArray(isArray), m_isRequired(isRequired),
      m_entry{DBStore::Instance().getEntry(name, objClass, isArray, isRequired)}, m_changed{isValid()}
    {
      if (m_entry) m_entry->registerAccessor(this);
    }







    DBAccessorBase(DBStoreEntry::EPayloadType type, const std::string& name, bool isRequired):
      m_type(type), m_name(name), m_objClass(nullptr), m_isArray(false), m_isRequired(isRequired),
      m_entry{DBStore::Instance().getEntry(type, name, nullptr, false, isRequired)}, m_changed{isValid()}
    {
      if (m_entry) m_entry->registerAccessor(this);
    }





    virtual ~DBAccessorBase()
    {
      if (m_entry) m_entry->removeAccessor(this);
    }


    const std::string& getName() const { return m_name; }





    inline bool isValid() const {if (!ensureAttached()) return false; return (m_entry->getObject() != nullptr);}

    inline operator bool() const {return isValid();}


    virtual bool operator==(const DBAccessorBase& other) const
    {
      return getName() == other.getName();
    }


    virtual bool operator!=(const DBAccessorBase& other) const
    {
      return !(*this == other);
    }


    bool hasChanged()
    {
      const bool ret = m_changed;
      m_changed = false;
      return ret;
    }
# 101 "include/framework/database/DBAccessorBase.h"
    void addCallback(std::function<void(const std::string&)> callback, bool onDestruction = false)
    {
      m_callbacks.emplace_back(callback, onDestruction);
    }
# 114 "include/framework/database/DBAccessorBase.h"
    void addCallback(std::function<void()> callback, bool onDestruction = false)
    {
      addCallback([callback](const std::string&) -> void { callback(); }, onDestruction);
    }
# 126 "include/framework/database/DBAccessorBase.h"
    template<class T> void addCallback(T* object, void(T::*callback)())
    {
      addCallback([ = ](const std::string&) {(*object.*callback)();});
    }


    const std::string& getGlobaltag() const { ensureAttached(); return m_entry->getGlobaltag(); }


    unsigned int getRevision() const { ensureAttached(); return m_entry->getRevision(); }


    IntervalOfValidity getIoV() const { ensureAttached(); return m_entry->getIoV(); }


    const std::string& getChecksum() const { ensureAttached(); return m_entry->getChecksum(); }


    const std::string& getFilename() const { ensureAttached(); return m_entry->getFilename(); }


    bool isIntraRunDependent() const { ensureAttached(); return m_entry->isIntraRunDependent(); }





    const std::vector<unsigned int> getIntraRunBoundaries() const { ensureAttached(); return m_entry->getIntraRunBoundaries(); }


    bool isRequired() const { ensureAttached(); return m_entry->isRequired(); }

  protected:

    template<class T = TObject> const T * getObject() const
    {
      if (!ensureAttached()) return nullptr;
      return reinterpret_cast<const T*>(m_entry->getObject());
    }


    bool ensureAttached() const
    {
      if (!m_entry) {
        do { if (Belle2::LogSystem::debugEnabled()) do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::LogConfig::c_Debug, 32, "klm")) { { LogVariableStream varStream; varStream << "DBAccessor " << m_name << " lost connection, reattaching"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Debug, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/database/DBAccessorBase.h", 170, 32)); }; } } while(false); } while(false);
        m_entry = DBStore::Instance().getEntry(m_type, m_name, m_objClass, m_isArray, m_isRequired);
        m_changed = true;
        if (!m_entry) return false;
        m_entry->registerAccessor(const_cast<DBAccessorBase*>(this));
      }
      return true;
    }


    void storeEntryChanged(bool destructed)
    {

      m_changed = true;

      if (destructed) m_entry = nullptr;



      for (const auto& cb : m_callbacks) {
        if (destructed == cb.second) cb.first(m_name);
      }
    }


    const DBStoreEntry::EPayloadType m_type;

    const std::string m_name;

    const TClass* m_objClass;

    const bool m_isArray;

    const bool m_isRequired;

    mutable DBStoreEntry* m_entry;

    mutable bool m_changed{false};

    std::vector<std::pair<std::function<void(const std::string&)>, bool>> m_callbacks;

    friend class DBStoreEntry;
  };
}
# 11 "include/framework/database/DBObjPtr.h" 2

namespace Belle2 {




  template<class T> class DBObjPtr: public DBAccessorBase {
  public:
# 27 "include/framework/database/DBObjPtr.h"
    explicit DBObjPtr(const std::string& name = "", bool required = true):
      DBAccessorBase(DBStore::objectName<T>(name), T::Class(), false, required) {}

    inline const T& operator *() const {return *getObject<T>(); }
    inline const T* operator ->() const {return getObject<T>(); }
  };
# 44 "include/framework/database/DBObjPtr.h"
  template<class T> class OptionalDBObjPtr: public DBObjPtr<T> {
  public:


    explicit OptionalDBObjPtr(const std::string& name = ""): DBObjPtr<T>(name, false) {}
  };
}
# 21 "klm/bklm/geometry/src/GeometryPar.cc" 2
# 1 "include/simulation/background/BkgSensitiveDetector.h" 1
# 11 "include/simulation/background/BkgSensitiveDetector.h"
# 1 "include/simulation/kernel/SensitiveDetectorBase.h" 1
# 11 "include/simulation/kernel/SensitiveDetectorBase.h"
# 1 "include/framework/datastore/RelationArray.h" 1
# 13 "include/framework/datastore/RelationArray.h"
# 1 "include/framework/utilities/ArrayIterator.h" 1
# 13 "include/framework/utilities/ArrayIterator.h"
class TObject;

namespace Belle2 {



  template <class ArrayType, class ValueType> class ObjArrayIterator {

  public:


    using iterator_category = std::forward_iterator_tag;


    using difference_type = std::ptrdiff_t;


    using value_type = ValueType;


    using pointer = ValueType*;


    using reference = ValueType&;


    ObjArrayIterator() = default;




    ObjArrayIterator(ArrayType& array, size_t index): m_array{array.GetObjectRef() + index} {}
# 53 "include/framework/utilities/ArrayIterator.h"
    explicit ObjArrayIterator(ArrayType const* array, bool end = false)
    {
      if (array) {
        m_array = array->GetObjectRef() + (end ? array->GetEntriesFast() : 0);
      }
    }
# 67 "include/framework/utilities/ArrayIterator.h"
    explicit ObjArrayIterator(ArrayType const* const* array, bool end = false): ObjArrayIterator(array ? * array : nullptr, end) {}

    ObjArrayIterator<ArrayType, ValueType>& operator++() { ++m_array; return *this; }

    ObjArrayIterator<ArrayType, ValueType> operator++(int) { auto old = *this; ++(*this); return old; }

    bool operator==(const ObjArrayIterator<ArrayType, ValueType>& rhs) const { return m_array == rhs.m_array; }

    bool operator!=(const ObjArrayIterator<ArrayType, ValueType>& rhs) const { return !(*this == rhs); }


    ValueType& operator*() const { return *static_cast<ValueType*>(*m_array); }

    ValueType* operator->() const { return &(operator*()); }
  private:

    TObject** m_array{nullptr};
  };
# 98 "include/framework/utilities/ArrayIterator.h"
  template <class ArrayType, class ValueType> class ArrayIterator {

  public:


    using iterator_category = std::forward_iterator_tag;


    using difference_type = std::ptrdiff_t;


    using value_type = ValueType;


    using pointer = ValueType*;


    using reference = ValueType&;

  public:


    ArrayIterator(): m_array(nullptr), m_index(-1)
    {
    }


    explicit ArrayIterator(const ArrayType* array, int index):
      m_array(array), m_index(index)
    {
    }


    ArrayIterator<ArrayType, ValueType>& operator++()
    {
      ++m_index;
      return *this;
    }


    ArrayIterator<ArrayType, ValueType> operator++(int)
    {
      ArrayIterator<ArrayType, ValueType> old(*this);
      ++(*this);
      return old;
    }


    bool operator==(const ArrayIterator<ArrayType, ValueType>& rhs) const
    {
      return m_index == rhs.m_index && m_array == rhs.m_array;
    }


    bool operator!=(const ArrayIterator<ArrayType, ValueType>& rhs) const
    {
      return !(*this == rhs);
    }


    ValueType& operator*() const
    {
      return deref_if_needed((*m_array)[m_index]);
    }


    ValueType* operator->() const
    {
      return &(operator*());
    }

  private:


    static ValueType& deref_if_needed(ValueType& t)
    {
      return t;
    }


    static ValueType& deref_if_needed(ValueType* t)
    {
      return *t;
    }


    const ArrayType* m_array;


    int m_index;

  };
}
# 14 "include/framework/datastore/RelationArray.h" 2
# 1 "include/framework/dataobjects/RelationElement.h" 1
# 16 "include/framework/dataobjects/RelationElement.h"
namespace Belle2 {




  class RelationElement: public TObject {
  public:


    typedef unsigned int index_type;


    typedef float weight_type;


    RelationElement();
# 40 "include/framework/dataobjects/RelationElement.h"
    RelationElement(index_type from, index_type to, weight_type weight = 1.0):
      TObject(), m_from(from), m_to(1, to), m_weights(1, weight) {}







    RelationElement(index_type from, const std::vector<index_type>& to, const std::vector<weight_type>& weights);
# 59 "include/framework/dataobjects/RelationElement.h"
    template <class InputIterator> RelationElement(index_type from, const InputIterator& begin, const InputIterator& end):
      TObject(), m_from(from)
    {
      setToIndices(begin, end);
    }


    index_type getFromIndex() const { return m_from; }


    size_t getSize() const { return m_to.size(); }


    std::pair<index_type, weight_type> getTo(size_t n = 0) const { return std::make_pair(m_to[n], m_weights[n]); }


    index_type getToIndex(size_t n = 0) const { return m_to[n]; }


    weight_type getWeight(size_t n = 0) const { return m_weights[n]; }


    const std::vector<index_type>& getToIndices() const { return m_to; }


    const std::vector<weight_type>& getWeights() const { return m_weights; }


    void setFromIndex(index_type from) { m_from = from; }


    void setToIndex(index_type to, weight_type weight = 1.0)
    {
      m_to = std::vector<index_type>(1, to);
      m_weights = std::vector<weight_type>(1, weight);
    }
# 103 "include/framework/dataobjects/RelationElement.h"
    template<class InputIterator> void setToIndices(InputIterator begin, const InputIterator& end)
    {
      for (; begin != end; ++begin) {
        m_to.push_back(begin->first);
        m_weights.push_back(begin->second);
      }
    }

  protected:


    index_type m_from;


    std::vector<index_type> m_to;


    std::vector<weight_type> m_weights;

    private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("RelationElement") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return RelationElement::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(RelationElement::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { RelationElement::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/dataobjects/RelationElement.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 122; };
  };

}
# 15 "include/framework/datastore/RelationArray.h" 2
# 1 "include/framework/dataobjects/RelationContainer.h" 1
# 11 "include/framework/dataobjects/RelationContainer.h"
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TClonesArray.h" 1 3
# 27 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TClonesArray.h" 3
class TClass;

class TClonesArray : public TObjArray {

protected:
   TClass *fClass;
   TObjArray *fKeep;

public:
   enum EStatusBits {
      kBypassStreamer = (1ULL << (12)),
      kForgetBits = (1ULL << (15))
   };

   TClonesArray();
   TClonesArray(const char *classname, Int_t size = 1000, Bool_t call_dtor = kFALSE);
   TClonesArray(const TClass *cl, Int_t size = 1000, Bool_t call_dtor = kFALSE);
   TClonesArray(const TClonesArray& tc);
   virtual ~TClonesArray();
   TClonesArray& operator=(const TClonesArray& tc);
   void Compress() override;
   void Clear(Option_t *option="") override;
   void Delete(Option_t *option="") override;
   void Expand(Int_t newSize) override;
   virtual void ExpandCreate(Int_t n);
   virtual void ExpandCreateFast(Int_t n);
   TClass *GetClass() const { return fClass; }
   void SetOwner(Bool_t enable = kTRUE) override;

   void AddFirst(TObject *) override { MayNotUse("AddFirst"); }
   void AddLast(TObject *) override { MayNotUse("AddLast"); }
   void AddAt(TObject *, Int_t) override { MayNotUse("AddAt"); }
   void AddAtAndExpand(TObject *, Int_t) override { MayNotUse("AddAtAndExpand"); }
   Int_t AddAtFree(TObject *) override { MayNotUse("AddAtFree"); return 0; }
   void AddAfter(const TObject *, TObject *) override { MayNotUse("AddAfter"); }
   void AddBefore(const TObject *, TObject *) override { MayNotUse("AddBefore"); }
   void BypassStreamer(Bool_t bypass=kTRUE);
   Bool_t CanBypassStreamer() const { return TestBit(kBypassStreamer); }
   TObject *ConstructedAt(Int_t idx);
   TObject *ConstructedAt(Int_t idx, Option_t *clear_options);
   void SetClass(const char *classname,Int_t size=1000);
   void SetClass(const TClass *cl,Int_t size=1000);

   void AbsorbObjects(TClonesArray *tc);
   void AbsorbObjects(TClonesArray *tc, Int_t idx1, Int_t idx2);
   void MultiSort(Int_t nTCs, TClonesArray** tcs, Int_t upto = kMaxInt);
   TObject *RemoveAt(Int_t idx) override;
   TObject *Remove(TObject *obj) override;
   void RemoveRange(Int_t idx1, Int_t idx2) override;
   void Sort(Int_t upto = kMaxInt) override;

   TObject *New(Int_t idx);
   TObject *AddrAt(Int_t idx);
   TObject *&operator[](Int_t idx) override;
   TObject *operator[](Int_t idx) const override;

   private: static_assert(std::is_integral<decltype(4)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("TClonesArray") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 4; } TClass *IsA() const override { return TClonesArray::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(TClonesArray::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { TClonesArray::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/TClonesArray.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 83; }
};

inline TObject *TClonesArray::AddrAt(Int_t idx)
{
   return operator[](idx);
}
# 12 "include/framework/dataobjects/RelationContainer.h" 2


namespace Belle2 {
  class RelationElement;







  class RelationContainer: public TObject {
  public:


    RelationContainer();


    const std::string& getFromName() const { return m_fromName; }


    int getFromDurability() const { return m_fromDurability; }


    const std::string& getToName() const { return m_toName; }


    int getToDurability() const { return m_toDurability; }


    void setFromName(const std::string& name) { m_fromName = name; }


    void setFromDurability(int durability) { m_fromDurability = durability; }


    void setToName(const std::string& name) { m_toName = name; }


    void setToDurability(int durability) { m_toDurability = durability; }


    void setModified(bool modified) { m_modified = modified; }


    bool isDefaultConstructed() const
    {
      return (m_fromDurability == -1 and m_toDurability == -1 and
              m_fromName.empty() and m_toName.empty() and getEntries() == 0);
    }


    virtual void Clear(Option_t* = "");


    TClonesArray& elements() { return m_elements; }


    const TClonesArray& elements() const { return m_elements; }


    const RelationElement& getElement(int i) const;


    int getEntries() const { return m_elements.GetEntriesFast(); }


    bool getModified() const { return m_modified; }

  protected:


    TClonesArray m_elements;


    std::string m_fromName;


    int m_fromDurability;


    std::string m_toName;


    int m_toDurability;


    bool m_modified;

    friend class RelationArray;
    friend class DataStore;

    private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("RelationContainer") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return RelationContainer::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(RelationContainer::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { RelationContainer::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/dataobjects/RelationContainer.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 104; };
  };
}
# 16 "include/framework/datastore/RelationArray.h" 2


namespace Belle2 {
  template <class T> class StoreArray;
# 58 "include/framework/datastore/RelationArray.h"
  class RelationArray: public StoreAccessorBase {
  public:

    typedef ObjArrayIterator<const TClonesArray, const RelationElement> const_iterator;


    typedef RelationElement::index_type index_type;


    typedef RelationElement::weight_type weight_type;





    enum EConsolidationAction {
      c_doNothing,
      c_negativeWeight,
      c_zeroWeight,
      c_deleteElement
    };





    typedef std::pair<index_type, bool> consolidation_type;





    struct Identity {

      consolidation_type operator()(index_type old) const { return std::make_pair(old, false); }
    };






    template < class MapType = std::map<index_type, consolidation_type> > class ReplaceMap {
    public:


      explicit ReplaceMap(MapType& replace): m_replace(replace) {}


      consolidation_type operator()(index_type old) const
      {
        typename MapType::const_iterator iter = m_replace.find(old);
        if (iter != m_replace.end()) {
          return iter->second;
        }
        return std::make_pair(old, false);
      }

    private:


      MapType& m_replace;
    };







    template < class VecType = std::vector<consolidation_type> > class ReplaceVec {
    public:


      explicit ReplaceVec(VecType& replace): m_replace(replace) {}


      consolidation_type operator()(index_type old) const { return m_replace[old]; }

    private:


      VecType& m_replace;
    };







    bool create(bool replace = false)
    {
      bool result = DataStore::Instance().createObject(0, replace, *this);
      m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (result) {
        (*m_relations)->setFromName(m_accessorFrom.first);
        (*m_relations)->setFromDurability(m_accessorFrom.second);
        (*m_relations)->setToName(m_accessorTo.first);
        (*m_relations)->setToDurability(m_accessorTo.second);
      }
      return result;
    }
# 174 "include/framework/datastore/RelationArray.h"
    template <class FROM, class TO> RelationArray(const StoreArray<FROM>& from, const StoreArray<TO>& to, const std::string& name = "",
                                                  DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(name.empty() ? DataStore::relationName(from.getName(), to.getName()) : name, durability,
                        RelationContainer::Class(), false),
      m_accessorFrom(from.getAccessorParams()),
      m_accessorTo(to.getAccessorParams()),
      m_relations(0)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        do { { LogVariableStream varStream; varStream << "Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 183, 0)); }; exit(1); } while(false);
      }
    }
# 194 "include/framework/datastore/RelationArray.h"
    RelationArray(const AccessorParams& fromAccessor, const AccessorParams& toAccessor,
                  DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(DataStore::relationName(fromAccessor.first, toAccessor.first), durability, RelationContainer::Class(), false),
      m_accessorFrom(fromAccessor),
      m_accessorTo(toAccessor),
      m_relations(nullptr)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        do { { LogVariableStream varStream; varStream << "Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 202, 0)); }; exit(1); } while(false);
      }
    }
# 214 "include/framework/datastore/RelationArray.h"
    explicit RelationArray(const std::string& name, DataStore::EDurability durability = DataStore::c_Event):
      StoreAccessorBase(name, durability, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (name.empty()) {
        do { { LogVariableStream varStream; varStream << "Cannot guess relation name, please supply correct name"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 219, 0)); }; exit(1); } while(false);
      }
    }


    ~RelationArray() override {}





    inline bool isValid() const { ensureAttached(); return m_relations && *m_relations;}

    inline operator bool() const { return isValid(); }


    const RelationElement& operator[](int i) const { assertValid(); return (*m_relations)->getElement(i);}


    int getEntries() const { return isValid() ? ((*m_relations)->getEntries()) : 0; }


    const AccessorParams& getFromAccessorParams() const
    {
      ensureAttached();
      if (m_accessorFrom.first.empty())
        do { { LogVariableStream varStream; varStream << "trying to get accessor params from non-existing relation (this is likely a framework bug)"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 245, 0)); }; exit(1); } while(false);
      return m_accessorFrom;
    }


    const AccessorParams& getToAccessorParams() const
    {
      ensureAttached();
      if (m_accessorTo.first.empty())
        do { { LogVariableStream varStream; varStream << "trying to get accessor params from non-existing relation (this is likely a framework bug)"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 254, 0)); }; exit(1); } while(false);
      return m_accessorTo;
    }


    bool getModified() const { assertValid(); return (*m_relations)->getModified(); }


    void setModified(bool modified) { assertCreated(); (*m_relations)->setModified(modified); }


    void clear() override
    {
      setModified(true);
      (*m_relations)->elements().Delete();
    }







    void add(index_type from, index_type to, weight_type weight = 1.0)
    {
      setModified(true);
      new (next()) RelationElement(from, to, weight);
    }







    void add(index_type from, const std::vector<index_type>& to, weight_type weight = 1.0)
    {
      setModified(true);
      std::vector<weight_type> weights(to.size(), weight);
      new (next()) RelationElement(from, to, weights);
    }







    void add(index_type from, const std::vector<index_type>& to, const std::vector<weight_type>& weights)
    {
      setModified(true);
      new (next()) RelationElement(from, to, weights);
    }
# 316 "include/framework/datastore/RelationArray.h"
    template <class InputIterator> void add(index_type from, const InputIterator& begin, const InputIterator& end)
    {
      setModified(true);
      new (next()) RelationElement(from, begin, end);
    }






    void consolidate() { consolidate<Identity, Identity>(); }
# 359 "include/framework/datastore/RelationArray.h"
    template<class FunctionFrom, class FunctionTo> void consolidate(const
        FunctionFrom& replaceFrom = FunctionFrom(), const FunctionTo &
        replaceTo = FunctionTo(), EConsolidationAction action =
          c_doNothing);


    const_iterator begin() const { assertValid(); return const_iterator((*m_relations)->elements(), 0); }

    const_iterator end() const { assertValid(); return const_iterator((*m_relations)->elements(), getEntries()); }

  private:







    explicit RelationArray(const AccessorParams& params):
      StoreAccessorBase(params.first, params.second, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (params.first.empty()) {
        do { { LogVariableStream varStream; varStream << "Cannot guess relation name, please supply correct name"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 382, 0)); }; exit(1); } while(false);
      }
    }



    RelationElement* next()
    {
      int index = (*m_relations)->elements().GetLast() + 1;
      return static_cast<RelationElement*>((*m_relations)->elements().AddrAt(index));
    }


    void checkRelation(const std::string& direction, const AccessorParams& array, const AccessorParams& rel) const
    {
      if (array.second == 0 && array.first.empty())
        return;

      if (array != rel) {
        do { { LogVariableStream varStream; varStream << "Relation '" << m_name << "' exists but points " << direction << " wrong array:" << " requested " << array.first << "(" << array.second << ")" << ", got " << rel.first << "(" << rel.second << ")"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 404, 0)); }; exit(1); } while(false);



      }
    }


    void ensureAttached() const
    {
      if (m_relations)
        return;

      const_cast<RelationArray*>(this)->m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (m_relations && *m_relations && !(*m_relations)->isDefaultConstructed()) {
        AccessorParams fromAccessorRel((*m_relations)->getFromName(), (DataStore::EDurability)(*m_relations)->getFromDurability());
        AccessorParams toAccessorRel((*m_relations)->getToName(), (DataStore::EDurability)(*m_relations)->getToDurability());

        if (m_accessorFrom.first.empty())
          const_cast<RelationArray*>(this)->m_accessorFrom = fromAccessorRel;
        if (m_accessorTo.first.empty())
          const_cast<RelationArray*>(this)->m_accessorTo = toAccessorRel;
        checkRelation("from", m_accessorFrom, fromAccessorRel);
        checkRelation("to", m_accessorTo, toAccessorRel);
      } else {

        const_cast<RelationArray*>(this)->m_relations = nullptr;
      }
    }


    void assertValid() const { if (!isValid()) do { { LogVariableStream varStream; varStream << "RelationArray does not point to valid StoreObject"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 432, 0)); }; exit(1); } while(false); }





    void assertCreated()
    {
      if (!isValid()) {
        if (!create()) {
          do { { LogVariableStream varStream; varStream << "Couldn't create relation " << m_name << "!"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 442, 0)); }; exit(1); } while(false);
        }
      }
    }


    AccessorParams m_accessorFrom;


    AccessorParams m_accessorTo;


    RelationContainer** m_relations;

    template<class FROM, class TO> friend class RelationIndex;
    template<class FROM, class TO> friend class RelationIndexContainer;

  };

  template<class FunctionFrom, class FunctionTo>
  void RelationArray::consolidate(const FunctionFrom& replaceFrom, const FunctionTo& replaceTo, EConsolidationAction action)
  {
    if (!isValid()) {
      do { { LogVariableStream varStream; varStream << "Cannot consolidate an invalid relation (" << m_name << ")"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Error, std::move(varStream), "klm", __PRETTY_FUNCTION__, "include/framework/datastore/RelationArray.h", 465, 0)); } } while(false);
      return;
    }
    typedef std::map<index_type, weight_type> element_t;
    typedef std::map<index_type, element_t > buffer_t;
    buffer_t buffer;



    index_type lastFromIndex(0);
    buffer_t::iterator lastFromIter = buffer.end();
    unsigned int nElements = (*m_relations)->getEntries();
    TClonesArray& elements = (*m_relations)->elements();
    for (unsigned int i = 0; i < nElements; ++i) {
      const RelationElement& element = *static_cast<RelationElement*>(elements[i]);

      consolidation_type from = replaceFrom(element.getFromIndex());


      if (action == c_deleteElement && from.second) continue;



      if (from.first != lastFromIndex || lastFromIter == buffer.end()) {
        lastFromIter = buffer.insert(make_pair(from.first, element_t())).first;
        lastFromIndex = from.first;
      }

      size_t size = element.getSize();
      for (size_t j = 0; j < size; ++j) {

        consolidation_type to = replaceTo(element.getToIndex(j));

        if (action == c_deleteElement && to.second) continue;
        double weight = element.getWeight(j);





        if (from.second || to.second) {
          if (action == c_zeroWeight) {
            weight = 0;
          } else if (action == c_negativeWeight && weight > 0) {
            weight = -weight;
          }
        }

        lastFromIter->second[to.first] += weight;
      }
    }

    elements.Delete();

    for (buffer_t::iterator iter = buffer.begin(); iter != buffer.end(); ++iter) {
      add(iter->first, iter->second.begin(), iter->second.end());
    }
  }

}
# 12 "include/simulation/kernel/SensitiveDetectorBase.h" 2
# 1 "include/simulation/kernel/UserInfo.h" 1
# 12 "include/simulation/kernel/UserInfo.h"
# 1 "include/mdst/dataobjects/MCParticleGraph.h" 1
# 12 "include/mdst/dataobjects/MCParticleGraph.h"
# 1 "include/framework/core/MemoryPool.h" 1
# 15 "include/framework/core/MemoryPool.h"
namespace Belle2 {
# 29 "include/framework/core/MemoryPool.h"
  template < class T, int chunkSize = 128 > class MemoryPool {

  public:




    explicit MemoryPool(int n = 0): m_entries(0) { reserve(n); }


    ~MemoryPool() { release_memory(); }





    size_t size() const { return m_entries; }






    T* operator[](size_t i) { return m_chunks[i / chunkSize] + i % chunkSize; }






    T* at(size_t i) { return (i >= m_entries) ? 0 : (*this)[i]; }




    void clear() { m_entries = 0; }





    T* add()
    {
      if (m_entries / chunkSize >= m_chunks.size()) {
        m_chunks.push_back(reinterpret_cast<T*>(malloc(chunkSize * sizeof(T))));
      }
      return (*this)[m_entries++];
    }





    void reserve(size_t n)
    {
      size_t needed_chunks = n / chunkSize + 1;
      m_chunks.reserve(needed_chunks);
      while (m_chunks.size() < needed_chunks) {
        m_chunks.push_back(reinterpret_cast<T*>(malloc(chunkSize * sizeof(T))));
      }
    }




    void release_memory()
    {
      for (T* ptr : m_chunks) {
        free(reinterpret_cast<void*>(ptr));
      }
      m_chunks.clear();
    }

  protected:

    size_t m_entries;
    std::vector<T*> m_chunks;
  };

}
# 13 "include/mdst/dataobjects/MCParticleGraph.h" 2
# 1 "include/mdst/dataobjects/MCParticle.h" 1
# 11 "include/mdst/dataobjects/MCParticle.h"
# 1 "include/framework/gearbox/Const.h" 1
# 19 "include/framework/gearbox/Const.h"
class TDatabasePDG;
class TParticlePDG;

namespace Belle2 {







  class Const {

  public:





    enum EDetector {
      invalidDetector = 0x0,
      PXD = 0x1,
      SVD = 0x2,
      CDC = 0x3,
      TOP = 0x4,
      ARICH = 0x5,
      ECL = 0x6,
      KLM = 0x7,
      BKLM = 0x100 + KLM,
      EKLM = 0x200 + KLM,
      IR = 0x8,
      TRG = 0x9,
      DAQ = 0xA,
      BEAST = 0xB,
      TEST = 0xC,
    };





    enum ERunType {
      c_Beam,
      c_Cosmic
    };






    static std::string parseDetectors(EDetector det);





    class DetectorSet {
    public:




      class Iterator {

      public:







        Iterator(int index, uint16_t detectorSetBits, uint16_t setBit) :
          m_Index(index),
          m_DetectorSetBits(detectorSetBits),
          m_SetBit(setBit)
        {
        }




        ~Iterator()
        {
        }




        Iterator& operator++();




        void increment()
        {
          ++(*this);
        }




        EDetector operator*() const
        {
          return DetectorSet::getDetector(m_SetBit);
        }




        EDetector getDetector() const
        {
          return *(*this);
        }




        bool operator==(const Iterator& iterator) const;




        bool operator!=(const Iterator& iterator) const;




        int getIndex() const
        {
          return m_Index;
        }




        uint16_t getSetBit() const
        {
          return m_SetBit;
        }

      private:


        int m_Index;


        uint16_t m_DetectorSetBits;


        uint16_t m_SetBit;

      };


      DetectorSet(): m_bits(0) {}

      DetectorSet(const DetectorSet&) = default;

      DetectorSet& operator=(const DetectorSet&) = default;






      DetectorSet(EDetector det): m_bits(getBit(det)) {}




      virtual ~DetectorSet() {};




      Iterator begin() const;




      Iterator end() const;





      DetectorSet& operator += (const DetectorSet& set) {m_bits |= set.m_bits; return *this;}





      DetectorSet& operator -= (const DetectorSet& set) {m_bits &= ~set.m_bits; return *this;}





      bool operator == (const DetectorSet& set) const {return m_bits == set.m_bits;}





      bool operator != (const DetectorSet& set) const {return m_bits != set.m_bits;}





      bool contains(const DetectorSet& set) const {return (m_bits & set.m_bits) == set.m_bits;}





      bool contains(const Iterator& it) const
      {
        return (m_bits & it.getSetBit()) != 0;
      }






      int getIndex(EDetector det) const;




      size_t size() const;




      std::string __str__() const;

    private:





      explicit DetectorSet(uint16_t bits): m_bits(bits) {};






      static uint16_t getBit(EDetector det);






      static EDetector getDetector(uint16_t bit);


      uint16_t m_bits;


      private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("DetectorSet") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return DetectorSet::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(DetectorSet::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { DetectorSet::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/gearbox/Const.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 285; };

    };




    template <class ASetType> class RestrictedDetectorSet: public DetectorSet {
    public:




      class InvalidDetectorTypeError : public std::runtime_error { public: InvalidDetectorTypeError(): std::runtime_error(""), m_format("The given detector is not a valid element of the set!") { } ~InvalidDetectorTypeError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> InvalidDetectorTypeError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };




      RestrictedDetectorSet(): DetectorSet() {}






      RestrictedDetectorSet(const DetectorSet& set): DetectorSet(set) {checkSet();}






      RestrictedDetectorSet(EDetector det): DetectorSet(det) {checkSet();}





      RestrictedDetectorSet& operator += (const DetectorSet& set) {DetectorSet::operator +=(set); checkSet(); return *this;}





      static DetectorSet set() {return ASetType::set();}

    private:




      void checkSet() const {if (!ASetType::set().contains(*this)) throw InvalidDetectorTypeError();}
    };






    class VXDDetectors {
    public:
      static DetectorSet set() {return c_set;}
      static const DetectorSet c_set;
    };

    typedef RestrictedDetectorSet<VXDDetectors> VXDDetectorSet;





    class TrackingDetectors {
    public:
      static DetectorSet set() {return c_set;}
      static const DetectorSet c_set;
    };

    typedef RestrictedDetectorSet<TrackingDetectors> TrackingDetectorSet;





    class PIDDetectors {
    public:
      static DetectorSet set() {return c_set;}
      static const DetectorSet c_set;
      static const size_t c_size = 6;
    };

    typedef RestrictedDetectorSet<PIDDetectors> PIDDetectorSet;





    class ClusterDetectors {
    public:
      static DetectorSet set() {return c_set;}
      static const DetectorSet c_set;
      static const size_t c_size = 2;
    };

    typedef RestrictedDetectorSet<ClusterDetectors> ClusterDetectorSet;





    static const DetectorSet allDetectors;

    class ParticleSet;







    class ParticleType {
    public:







      explicit ParticleType(int pdgCode, const ParticleSet* set = nullptr, int index = -1):
        m_pdgCode(pdgCode), m_set(set), m_index(index) {}


      ParticleType(const ParticleType&) = default;

      ParticleType& operator=(const ParticleType&) = default;





      bool operator < (const ParticleType& other) const;


      bool operator==(const ParticleType& o) const { return m_pdgCode == o.m_pdgCode; }


      bool operator!=(const ParticleType& o) const { return !((*this) == o); }


      ParticleType& operator*() { return *this; }





      ParticleType& operator++();





      ParticleType operator++(int);




      operator ParticleSet() const { ParticleSet s; s.add(*this); return s; }





      int getIndex() const { return m_index; }





      const TParticlePDG* getParticlePDG() const;





      int getPDGCode() const {return m_pdgCode;};





      double getMass() const;




      std::string __repr__() const;

    private:
      int m_pdgCode;
      const ParticleSet* m_set;
      int m_index;
    };
# 513 "include/framework/gearbox/Const.h"
    class ParticleSet {
    public:

      ParticleSet() = default;


      ParticleSet(const ParticleSet& other)
      {
        for (const ParticleType& pdgIter : other) add(pdgIter);
      }


      ParticleSet& operator=(const ParticleSet& other)
      {
        m_particles.clear();
        for (const ParticleType& pdgIter : other) add(pdgIter);
        return *this;
      }





      void add(const ParticleType& p);


      bool contains(const ParticleType& p) const;


      unsigned int size() const { return m_particles.size(); }


      const ParticleType& at(unsigned int index) const
      {
        if (index < m_particles.size())
          return m_particles[index];
        return invalidParticle;
      }


      ParticleType begin() const
      {
        if (m_particles.empty())
          return end();
        return m_particles[0];
      }


      static ParticleType end()
      {
        return invalidParticle;
      }


      const ParticleType& find(int pdg) const
      {
        for (const ParticleType& pdgIter : *this) {
          if (pdgIter.getPDGCode() == pdg)
            return m_particles[pdgIter.getIndex()];
        }

        return invalidParticle;
      }
    private:
      std::vector<ParticleType> m_particles;
    };






    class ChargedStable : public ParticleType {
    public:





      ChargedStable(const ParticleType& p)
        : ParticleType(chargedStableSet.find(p.getPDGCode()))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given ParticleType is not a charged stable particle!");
        }
      }





      explicit ChargedStable(int pdg)
        : ParticleType(chargedStableSet.find(pdg))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given PDG code is not a charged stable particle!");
        }
      }
      static const unsigned int c_SetSize = 6;
    };

    static const ParticleSet chargedStableSet;







    class Cluster : public ParticleType {
    public:





      Cluster(const ParticleType& p)
        : ParticleType(clusterSet.find(p.getPDGCode()))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given ParticleType is not a cluster particle!");
        }
      }





      explicit Cluster(int pdg)
        : ParticleType(clusterSet.find(pdg))
      {
        if ((*this) == invalidParticle) {
          throw std::runtime_error("Given PDG code is not a cluster particle!");
        }
      }
      static const unsigned int c_SetSize = 6;
    };

    static const ParticleSet clusterSet;

    static const ParticleSet finalStateParticlesSet;

    static const ChargedStable electron;
    static const ChargedStable muon;
    static const ChargedStable pion;
    static const ChargedStable kaon;
    static const ChargedStable proton;
    static const ChargedStable deuteron;

    static const Cluster clusterphoton;
    static const Cluster clusterKlong;
    static const Cluster clusterelectron;
    static const Cluster clusterpion;
    static const Cluster clustermuon;
    static const Cluster clusterjunk;

    static const ParticleType photon;
    static const ParticleType pi0;
    static const ParticleType neutron;
    static const ParticleType antiNeutron;
    static const ParticleType Kshort;
    static const ParticleType Klong;
    static const ParticleType Lambda;
    static const ParticleType antiLambda;
    static const ParticleType invalidParticle;

    static const ParticleType unspecifiedParticle;

    static const double electronMass;
    static const double muonMass;
    static const double pionMass;
    static const double kaonMass;
    static const double protonMass;
    static const double deuteronMass;
    static const double pi0Mass;
    static const double neutronMass;
    static const double K0Mass;

    static const double speedOfLight;
    static const double kBoltzmann;
    static const double ehEnergy;
    static const double fineStrConst;
    static const double permSi;
    static const double uTherm;
    static const double eMobilitySi;

    static const double doubleNaN;
    static const float floatNaN;

  private:




    Const() = delete;
    Const(const Const&) = delete;
    Const& operator=(const Const&) = delete;
    ~Const() = delete;


  };
}




Belle2::Const::DetectorSet operator + (const Belle2::Const::DetectorSet& firstSet, const Belle2::Const::DetectorSet& secondSet);




Belle2::Const::DetectorSet operator - (const Belle2::Const::DetectorSet& firstSet, const Belle2::Const::DetectorSet& secondSet);




Belle2::Const::DetectorSet operator + (Belle2::Const::EDetector firstDet, Belle2::Const::EDetector secondDet);




Belle2::Const::ParticleSet operator + (const Belle2::Const::ParticleSet& firstSet, const Belle2::Const::ParticleSet& secondSet);
# 12 "include/mdst/dataobjects/MCParticle.h" 2

# 1 "include/framework/datastore/RelationsObject.h" 1
# 12 "include/framework/datastore/RelationsObject.h"
# 1 "include/framework/datastore/RelationVector.h" 1
# 11 "include/framework/datastore/RelationVector.h"
# 1 "include/framework/datastore/RelationEntry.h" 1
# 11 "include/framework/datastore/RelationEntry.h"
class TObject;

namespace Belle2 {






  struct RelationEntry {





    explicit RelationEntry(TObject* obj = nullptr, float w = 1.0): object(obj), weight(w) {}

    TObject* object;
    float weight;
  };
}
# 12 "include/framework/datastore/RelationVector.h" 2






namespace Belle2 {

  class RelationVectorBase {
  public:

    RelationVectorBase() { }


    RelationVectorBase(const std::string& name, int index, const std::vector<Belle2::RelationEntry>& relations,
                       const std::vector<std::string>& names): m_name(name), m_index(index), m_relations(relations), m_relationNames(names) {}

  protected:

    void add(const RelationVectorBase& other);


    void apply(int index, const std::function<void(std::vector<unsigned int>&, std::vector<float>&, size_t)>& f);

    std::string m_name;
    int m_index{ -1};
    std::vector<RelationEntry> m_relations;
    std::vector<std::string> m_relationNames;
    friend class DataStore;
  };
# 63 "include/framework/datastore/RelationVector.h"
  template <class T> class RelationVector : protected RelationVectorBase {
  public:

    typedef ArrayIterator<RelationVector<T>, T> iterator;

    typedef ArrayIterator<RelationVector<T>, const T> const_iterator;






    explicit RelationVector(const RelationVectorBase& b): RelationVectorBase(b) {}





    const std::vector<Belle2::RelationEntry>& relations() const {return m_relations;}


    size_t size() const { return m_relations.size();}







    T* object(int index) const {return static_cast<T*>(m_relations[index].object);}






    T* operator[](int index) const {return object(index);}






    float weight(int index) const {return m_relations[index].weight;}
# 115 "include/framework/datastore/RelationVector.h"
    void remove(int index)
    {
      apply(index, [](std::vector<unsigned int>& indices, std::vector<float>& weights,
      size_t elidx) {
        indices.erase(indices.begin() + elidx);
        weights.erase(weights.begin() + elidx);
      });

      m_relations.erase(m_relations.begin() + index);
    }


    void setWeight(int index, float weight)
    {
      apply(index, [weight](std::vector<unsigned int>&, std::vector<float>& weights, size_t elidx) {
        weights[elidx] = weight;
      });

      m_relations[index].weight = weight;
    }


    iterator begin() { return iterator(this, 0); }

    iterator end() { return iterator(this, size()); }


    const_iterator begin() const { return const_iterator(this, 0); }

    const_iterator end() const { return const_iterator(this, size()); }
  };
}
# 13 "include/framework/datastore/RelationsObject.h" 2






class TClonesArray;

namespace Belle2 {

  namespace _RelationsInterfaceImpl {

    std::string htmlToPlainText(const std::string& html);
  };
# 96 "include/framework/datastore/RelationsObject.h"
  template <class BASE> class RelationsInterface: public BASE {

    static_assert(std::is_same<TObject, BASE>::value,
                  "Using RelationsInterface<BASE> is no longer allowed. Please use RelationsObject as a base class.");
  public:


    RelationsInterface(): m_cacheDataStoreEntry(nullptr), m_cacheArrayIndex(-1) {}


    template<class ...Args> explicit RelationsInterface(Args&& ... params):
      BASE(std::forward<Args>(params)...),
      m_cacheDataStoreEntry(nullptr), m_cacheArrayIndex(-1) { }






    RelationsInterface(const RelationsInterface& relationsInterface):
      BASE(relationsInterface),
      m_cacheDataStoreEntry(nullptr), m_cacheArrayIndex(-1) { }






    RelationsInterface& operator=(const RelationsInterface& relationsInterface)
    {
      if (this != &relationsInterface)
        this->BASE::operator=(relationsInterface);
      return *this;
    }
# 138 "include/framework/datastore/RelationsObject.h"
    void addRelationTo(const RelationsInterface<BASE>* object, float weight = 1.0, const std::string& namedRelation = "") const
    {
      if (object)
        DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                          object, object->m_cacheDataStoreEntry, object->m_cacheArrayIndex, weight, namedRelation);
    }







    void addRelationTo(const TObject* object, float weight = 1.0, const std::string& namedRelation = "") const
    {
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex, object, toEntry, toIndex, weight, namedRelation);
    }
# 166 "include/framework/datastore/RelationsObject.h"
    void copyRelations(const RelationsInterface<BASE>* sourceObj)
    {
      if (!sourceObj)
        return;
      auto fromRels = sourceObj->getRelationsFrom<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < fromRels.size(); iRel++) {
        fromRels.object(iRel)->addRelationTo(this, fromRels.weight(iRel));
      }

      auto toRels = sourceObj->getRelationsTo<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < toRels.size(); iRel++) {
        this->addRelationTo(toRels.object(iRel), toRels.weight(iRel));
      }
    }
# 193 "include/framework/datastore/RelationsObject.h"
    template <class TO> RelationVector<TO> getRelationsTo(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return RelationVector<TO>(DataStore::Instance().getRelationsWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, TO::Class(), name, namedRelation));
    }
# 208 "include/framework/datastore/RelationsObject.h"
    template <class FROM> RelationVector<FROM> getRelationsFrom(const std::string& name = "",
                                                                const std::string& namedRelation = "") const
    {
      return RelationVector<FROM>(DataStore::Instance().getRelationsWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                  m_cacheArrayIndex, FROM::Class(), name, namedRelation));
    }
# 226 "include/framework/datastore/RelationsObject.h"
    template <class T> RelationVector<T> getRelationsWith(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return RelationVector<T>(DataStore::Instance().getRelationsWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry,
                               m_cacheArrayIndex, T::Class(), name, namedRelation));
    }
# 244 "include/framework/datastore/RelationsObject.h"
    template <class TO> TO* getRelatedTo(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<TO*>(DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                              TO::Class(), name, namedRelation).object);
    }
# 259 "include/framework/datastore/RelationsObject.h"
    template <class FROM> FROM* getRelatedFrom(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<FROM*>(DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, FROM::Class(), name, namedRelation).object);
    }
# 274 "include/framework/datastore/RelationsObject.h"
    template <class T> T* getRelated(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<T*>(DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                             T::Class(), name, namedRelation).object);
    }
# 293 "include/framework/datastore/RelationsObject.h"
    template <class TO> std::pair<TO*, float> getRelatedToWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  TO::Class(), name, namedRelation);
      return std::make_pair(static_cast<TO*>(entry.object), entry.weight);
    }
# 310 "include/framework/datastore/RelationsObject.h"
    template <class FROM> std::pair<FROM*, float> getRelatedFromWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  FROM::Class(), name, namedRelation);
      return std::make_pair(static_cast<FROM*>(entry.object), entry.weight);
    }
# 327 "include/framework/datastore/RelationsObject.h"
    template <class T> std::pair<T*, float> getRelatedWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  T::Class(), name, namedRelation);
      return std::make_pair(static_cast<T*>(entry.object), entry.weight);
    }






    virtual std::string getName() const { return ""; }
# 358 "include/framework/datastore/RelationsObject.h"
    virtual std::string getInfoHTML() const { return ""; }







    std::string getInfo() const
    {
      return _RelationsInterfaceImpl::htmlToPlainText(getInfoHTML());
    }



    std::string getArrayName() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheDataStoreEntry ? m_cacheDataStoreEntry->name : "";
    }



    int getArrayIndex() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheArrayIndex;
    }
# 411 "include/framework/datastore/RelationsObject.h"
  protected:


    TClonesArray* getArrayPointer() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      if (!m_cacheDataStoreEntry)
        return nullptr;
      return m_cacheDataStoreEntry->getPtrAsArray();
    }

  private:


    mutable DataStore::StoreEntry* m_cacheDataStoreEntry;


    mutable int m_cacheArrayIndex;

    friend class DataStore;


    private: static_assert(std::is_integral<decltype(0)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("RelationsInterface") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 0; } virtual TClass *IsA() const { return RelationsInterface::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(RelationsInterface::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { RelationsInterface::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/framework/datastore/RelationsObject.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 433; };
  };


  typedef RelationsInterface<TObject> RelationsObject;
}
# 14 "include/mdst/dataobjects/MCParticle.h" 2


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 1 3







# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 3
namespace ROOT {

  namespace Math {


    template<class CoordSystem, class Tag> class DisplacementVector3D;

    template<typename T> class Cartesian3D;
    template<typename T> class CylindricalEta3D;
    template<typename T> class Polar3D;
    template<typename T> class Cylindrical3D;

    class DefaultCoordinateSystemTag;
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 3
    typedef DisplacementVector3D< Cartesian3D<double>, DefaultCoordinateSystemTag > XYZVector;







    typedef DisplacementVector3D< Cartesian3D<float>, DefaultCoordinateSystemTag > XYZVectorF;
    typedef XYZVector XYZVectorD;
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 3
    typedef DisplacementVector3D< CylindricalEta3D<double>, DefaultCoordinateSystemTag > RhoEtaPhiVector;







    typedef DisplacementVector3D< CylindricalEta3D<float>, DefaultCoordinateSystemTag > RhoEtaPhiVectorF;
    typedef RhoEtaPhiVector RhoEtaPhiVectorD;
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 3
    typedef DisplacementVector3D< Polar3D<double>, DefaultCoordinateSystemTag > Polar3DVector;







    typedef DisplacementVector3D< Polar3D<float>, DefaultCoordinateSystemTag > Polar3DVectorF;
    typedef Polar3DVector Polar3DVectorD;
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3Dfwd.h" 3
    typedef DisplacementVector3D< Cylindrical3D<double>, DefaultCoordinateSystemTag > RhoZPhiVector;







    typedef DisplacementVector3D< Cylindrical3D<float>, DefaultCoordinateSystemTag > RhoZPhiVectorF;
    typedef RhoZPhiVector RhoZPhiVectorD;


  }

}
# 9 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 1 3
# 22 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3Dfwd.h" 1 3







namespace ROOT {

  namespace Math {






template <class T>
class Polar3D;

}
}
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Math.h" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Math.h" 3
namespace ROOT {







namespace Math {
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Math.h" 3
using std::atan2;
using std::cos;
using std::cosh;
using std::exp;
using std::floor;
using std::log;
using std::pow;
using std::sin;
using std::sinh;
using std::sqrt;
using std::tan;




inline double Pi()
{
   return 3.14159265358979323846;
   }






   inline double log1p(double x)
   {

   return ::log1p(x);






}

inline double expm1( double x) {

   return ::expm1(x);
# 137 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Math.h" 3
}

   }

}
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/eta.h" 1 3
# 20 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/eta.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/etaMax.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/etaMax.h" 3
namespace ROOT {

  namespace Math {







    inline
    long double etaMax_impl() {
      using std::log;
      return log ( std::numeric_limits<long double>::max()/256.0l ) -
             log ( std::numeric_limits<long double>::denorm_min()*256.0l )
             + 16.0 * log(2.0);


    }





    template <class T>
    inline
    T etaMax() {
      return static_cast<T>(22756.0);
    }

  }

}
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/eta.h" 2 3






namespace ROOT {

  namespace Math {

     namespace Impl {
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/eta.h" 3
        template<typename Scalar>
        inline Scalar Eta_FromRhoZ(Scalar rho, Scalar z) {
           if (rho > 0) {


              static const Scalar big_z_scaled = pow(std::numeric_limits<Scalar>::epsilon(), static_cast<Scalar>(-.25));

              Scalar z_scaled = z/rho;
              using std::fabs;
              if (std::fabs(z_scaled) < big_z_scaled) {
                 using std::sqrt;
                 using std::log;
                 return log(z_scaled + std::sqrt(z_scaled * z_scaled + 1.0));
              } else {

                 using std::log;
                 return z > 0 ? log(2.0 * z_scaled + 0.5 / z_scaled) : -log(-2.0 * z_scaled);
              }
           }

           else if (z==0) {
              return 0;
           }
           else if (z>0) {
              return z + etaMax<Scalar>();
           }
           else {
              return z - etaMax<Scalar>();
           }

        }






        template<typename Scalar>
        inline Scalar Eta_FromTheta(Scalar theta, Scalar r) {
           Scalar tanThetaOver2 = tan(theta / 2.);
           if (tanThetaOver2 == 0) {
              return r + etaMax<Scalar>();
           }
           else if (tanThetaOver2 > std::numeric_limits<Scalar>::max()) {
              return -r - etaMax<Scalar>();
           }
           else {
              using std::log;
              return -log(tanThetaOver2);
           }

        }

     }

  }

}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 2 3

namespace ROOT {

namespace Math {
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 3
template <class T = double>
class Cartesian3D {

public :

   typedef T Scalar;

   static constexpr unsigned int Dimension = 3U;




   Cartesian3D() : fX(0.0), fY(0.0), fZ(0.0) { }




   Cartesian3D(Scalar xx, Scalar yy, Scalar zz) : fX(xx), fY(yy), fZ(zz) { }





   template <class CoordSystem>
   explicit constexpr Cartesian3D(const CoordSystem & v)
      : fX(v.X()), fY(v.Y()), fZ(v.Z()) { }






   Cartesian3D(const Cartesian3D & v) :
      fX(v.X()), fY(v.Y()), fZ(v.Z()) { }




   Cartesian3D & operator= (const Cartesian3D & v) {
      fX = v.x();
      fY = v.y();
      fZ = v.z();
      return *this;
   }




   void SetCoordinates( const Scalar src[] ) { fX=src[0]; fY=src[1]; fZ=src[2]; }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fX; dest[1] = fY; dest[2] = fZ; }




   void SetCoordinates(Scalar xx, Scalar yy, Scalar zz) { fX=xx; fY=yy; fZ=zz; }




   void GetCoordinates(Scalar& xx, Scalar& yy, Scalar& zz) const {xx=fX; yy=fY; zz=fZ;}

   Scalar X() const { return fX;}
   Scalar Y() const { return fY;}
   Scalar Z() const { return fZ;}
   Scalar Mag2() const { return fX*fX + fY*fY + fZ*fZ;}
   Scalar Perp2() const { return fX*fX + fY*fY ;}
   Scalar Rho() const { using std::sqrt; return sqrt(Perp2()); }
   Scalar R() const { using std::sqrt; return sqrt(Mag2()); }
   Scalar Theta() const { using std::atan2; return atan2(Rho(), Z()); }
   Scalar Phi() const { using std::atan2; return atan2(fY, fX); }


   Scalar Eta() const {
      return Impl::Eta_FromRhoZ( Rho(), fZ );
   }




   void SetX(Scalar xx) { fX = xx; }




   void SetY(Scalar yy) { fY = yy; }




   void SetZ(Scalar zz) { fZ = zz; }




   void SetXYZ(Scalar xx, Scalar yy, Scalar zz) {
      fX=xx;
      fY=yy;
      fZ=zz;
   }




   void Scale(Scalar a)
   {
      fX *= a;
      fY *= a;
      fZ *= a;
   }




   void Negate() { fX = -fX; fY = -fY; fZ = -fZ; }





   template <class CoordSystem>
   Cartesian3D & operator = (const CoordSystem & v) {
      fX = v.x();
      fY = v.y();
      fZ = v.z();
      return *this;
   }




   bool operator == (const Cartesian3D & rhs) const {
      return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ;
   }
   bool operator != (const Cartesian3D & rhs) const {return !(operator==(rhs));}






   T x() const { return X();}
   T y() const { return Y();}
   T z() const { return Z(); }



   template <class T2>
   explicit constexpr Cartesian3D( const Polar3D<T2> & v ) : fZ (v.Z())
   {
      const T rho = v.Rho();


      fX = rho * std::cos(v.Phi());
      fY = rho * std::sin(v.Phi());
   }





   template <class T2>
   Cartesian3D & operator = (const Polar3D<T2> & v)
   {
      const T rho = v.Rho();
      using std::cos;
      fX = rho * cos(v.Phi());
      using std::sin;
      fY = rho * sin(v.Phi());
      fZ = v.Z();
      return *this;
   }
# 241 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cartesian3D.h" 3
private:

   T fX;
   T fY;
   T fZ;
};


  }

}
# 12 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 3
namespace ROOT {

namespace Math {
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 3
template <class T>
class CylindricalEta3D {

public :

  typedef T Scalar;
  static constexpr unsigned int Dimension = 3U;




  CylindricalEta3D() : fRho(0), fEta(0), fPhi(0) { }




  CylindricalEta3D(Scalar rho, Scalar eta, Scalar phi) :
             fRho(rho), fEta(eta), fPhi(phi) { Restrict(); }





  template <class CoordSystem >
  explicit CylindricalEta3D( const CoordSystem & v ) :
     fRho(v.Rho() ), fEta(v.Eta() ), fPhi(v.Phi() )
  {
     using std::log;
     static Scalar bigEta = Scalar(-0.3) * log(std::numeric_limits<Scalar>::epsilon());
     if (std::fabs(fEta) > bigEta) {



        fRho *= v.Z() / Z();
    }
  }







   CylindricalEta3D(const CylindricalEta3D & v) :
      fRho(v.Rho() ), fEta(v.Eta() ), fPhi(v.Phi() ) { }




   CylindricalEta3D & operator= (const CylindricalEta3D & v) {
      fRho = v.Rho();
      fEta = v.Eta();
      fPhi = v.Phi();
      return *this;
   }




   void SetCoordinates( const Scalar src[] )
   { fRho=src[0]; fEta=src[1]; fPhi=src[2]; Restrict(); }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fRho; dest[1] = fEta; dest[2] = fPhi; }




   void SetCoordinates(Scalar rho, Scalar eta, Scalar phi)
   { fRho=rho; fEta=eta; fPhi=phi; Restrict(); }




   void GetCoordinates(Scalar& rho, Scalar& eta, Scalar& phi) const
   {rho=fRho; eta=fEta; phi=fPhi;}

private:
   inline static Scalar pi() { return 3.14159265358979323846; }
   inline void Restrict() {
      using std::floor;
      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
      return;
   }
public:



   T Rho() const { return fRho; }
   T Eta() const { return fEta; }
   T Phi() const { return fPhi; }
   T X() const { using std::cos; return fRho * cos(fPhi); }
   T Y() const { using std::sin; return fRho * sin(fPhi); }
   T Z() const
   {
      using std::sinh;
      return fRho > 0 ? fRho * sinh(fEta) : fEta == 0 ? 0 : fEta > 0 ? fEta - etaMax<T>() : fEta + etaMax<T>();
   }
   T R() const
   {
      using std::cosh;
      return fRho > 0 ? fRho * cosh(fEta)
                      : fEta > etaMax<T>() ? fEta - etaMax<T>() : fEta < -etaMax<T>() ? -fEta - etaMax<T>() : 0;
   }
   T Mag2() const
   {
      const Scalar r = R();
      return r * r;
   }
   T Perp2() const { return fRho*fRho; }
   T Theta() const { using std::atan; return fRho > 0 ? 2 * atan(exp(-fEta)) : (fEta >= 0 ? 0 : pi()); }







   void SetRho(T rho) {
      fRho = rho;
   }




   void SetEta(T eta) {
      fEta = eta;
   }




   void SetPhi(T phi) {
      fPhi = phi;
      Restrict();
   }




   void SetXYZ(Scalar x, Scalar y, Scalar z);






   void Scale (T a) {
      if (a < 0) {
         Negate();
         a = -a;
      }

      if (fRho > 0) {
         fRho *= a;
      } else if ( fEta > etaMax<T>() ) {
         fEta = ( fEta-etaMax<T>())*a + etaMax<T>();
      } else if ( fEta < -etaMax<T>() ) {
         fEta = ( fEta+etaMax<T>())*a - etaMax<T>();
      }

   }




   void Negate ( ) {
      fPhi = ( fPhi > 0 ? fPhi - pi() : fPhi + pi() );
      fEta = -fEta;
   }





   template <class CoordSystem >
   CylindricalEta3D & operator= ( const CoordSystem & c ) {
      fRho = c.Rho();
      fEta = c.Eta();
      fPhi = c.Phi();
      return *this;
   }






   bool operator==(const CylindricalEta3D & rhs) const {
      return fRho == rhs.fRho && fEta == rhs.fEta && fPhi == rhs.fPhi;
   }
   bool operator!= (const CylindricalEta3D & rhs) const
   {return !(operator==(rhs));}






   T x() const { return X();}
   T y() const { return Y();}
   T z() const { return Z(); }
# 275 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 3
private:
   T fRho;
   T fEta;
   T fPhi;

};

  }

}
# 296 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 3
namespace ROOT {

  namespace Math {

template <class T>
void CylindricalEta3D<T>::SetXYZ(Scalar xx, Scalar yy, Scalar zz) {
   *this = Cartesian3D<Scalar>(xx, yy, zz);
}
# 350 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CylindricalEta3D.h" 3
  }

}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 3
namespace ROOT {

namespace Math {
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 3
template <class T>
class Polar3D {

public :

   typedef T Scalar;
   static constexpr unsigned int Dimension = 3U;




   Polar3D() : fR(0), fTheta(0), fPhi(0) { }




   Polar3D(T r,T theta,T phi) : fR(r), fTheta(theta), fPhi(phi) { Restrict(); }





   template <class CoordSystem >
   explicit constexpr Polar3D( const CoordSystem & v ) :
      fR(v.R() ), fTheta(v.Theta() ), fPhi(v.Phi() ) { Restrict(); }







   Polar3D(const Polar3D & v) :
      fR(v.R() ), fTheta(v.Theta() ), fPhi(v.Phi() ) { }




   Polar3D & operator= (const Polar3D & v) {
      fR = v.R();
      fTheta = v.Theta();
      fPhi = v.Phi();
      return *this;
   }




   void SetCoordinates( const Scalar src[] )
   { fR=src[0]; fTheta=src[1]; fPhi=src[2]; Restrict(); }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fR; dest[1] = fTheta; dest[2] = fPhi; }




   void SetCoordinates(Scalar r, Scalar theta, Scalar phi)
   { fR=r; fTheta=theta; fPhi=phi; Restrict(); }




   void GetCoordinates(Scalar& r, Scalar& theta, Scalar& phi) const {r=fR; theta=fTheta; phi=fPhi;}


   Scalar R() const { return fR;}
   Scalar Phi() const { return fPhi; }
   Scalar Theta() const { return fTheta; }
   Scalar Rho() const { using std::sin; return fR * sin(fTheta); }
   Scalar X() const { using std::cos; return Rho() * cos(fPhi); }
   Scalar Y() const { using std::sin; return Rho() * sin(fPhi); }
   Scalar Z() const { using std::cos; return fR * cos(fTheta); }
   Scalar Mag2() const { return fR*fR;}
   Scalar Perp2() const { return Rho() * Rho(); }


   Scalar Eta() const
   {
      return Impl::Eta_FromTheta(fTheta, fR);
   }







   void SetR(const T & r) {
      fR = r;
   }




   void SetTheta(const T & theta) {
      fTheta = theta;
   }




   void SetPhi(const T & phi) {
      fPhi = phi;
      Restrict();
   }




   void SetXYZ(Scalar x, Scalar y, Scalar z);


private:
   inline static Scalar pi() { return 3.14159265358979323846; }
   inline void Restrict() {
      using std::floor;
      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
   }

public:




   void Scale (T a) {
      if (a < 0) {
         Negate();
         a = -a;
      }

      fR *= a;
   }




   void Negate ( ) {
      fPhi = ( fPhi > 0 ? fPhi - pi() : fPhi + pi() );
      fTheta = pi() - fTheta;
   }





   template <class CoordSystem >
   Polar3D & operator= ( const CoordSystem & c ) {
      fR = c.R();
      fTheta = c.Theta();
      fPhi = c.Phi();
      return *this;
   }




   bool operator==(const Polar3D & rhs) const {
      return fR == rhs.fR && fTheta == rhs.fTheta && fPhi == rhs.fPhi;
   }
   bool operator!= (const Polar3D & rhs) const {return !(operator==(rhs));}






   T x() const { return X(); }
   T y() const { return Y(); }
   T z() const { return Z(); }
# 238 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 3
private:
   T fR;
   T fTheta;
   T fPhi;
};



  }

}
# 260 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 3
namespace ROOT {

  namespace Math {

template <class T>
void Polar3D<T>::SetXYZ(Scalar xx, Scalar yy, Scalar zz) {
   *this = Cartesian3D<Scalar>(xx, yy, zz);
}
# 310 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Polar3D.h" 3
  }

}
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 3
namespace ROOT {

namespace Math {
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 3
template <class T>
class Cylindrical3D {

public :

   typedef T Scalar;
   static constexpr unsigned int Dimension = 3U;




   Cylindrical3D() : fRho(0), fZ(0), fPhi(0) { }




   Cylindrical3D(Scalar rho, Scalar zz, Scalar phi) :
      fRho(rho), fZ(zz), fPhi(phi) { Restrict(); }





   template <class CoordSystem >
   explicit constexpr Cylindrical3D( const CoordSystem & v ) :
      fRho( v.Rho() ), fZ( v.Z() ), fPhi( v.Phi() ) { Restrict(); }







   Cylindrical3D(const Cylindrical3D & v) :
      fRho(v.Rho() ), fZ(v.Z() ), fPhi(v.Phi() ) { }




   Cylindrical3D & operator= (const Cylindrical3D & v) {
      fRho = v.Rho();
      fZ = v.Z();
      fPhi = v.Phi();
      return *this;
   }




   void SetCoordinates( const Scalar src[] )
   { fRho=src[0]; fZ=src[1]; fPhi=src[2]; Restrict(); }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fRho; dest[1] = fZ; dest[2] = fPhi; }




   void SetCoordinates(Scalar rho, Scalar zz, Scalar phi)
   { fRho=rho; fZ=zz; fPhi=phi; Restrict(); }




   void GetCoordinates(Scalar& rho, Scalar& zz, Scalar& phi) const
   {rho=fRho; zz=fZ; phi=fPhi;}

private:
   inline static Scalar pi() { return Scalar(3.14159265358979323846); }
   inline void Restrict()
   {
      using std::floor;
      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
   }
public:



   Scalar Rho() const { return fRho; }
   Scalar Z() const { return fZ; }
   Scalar Phi() const { return fPhi; }
   Scalar X() const { using std::cos; return fRho * cos(fPhi); }
   Scalar Y() const { using std::sin; return fRho * sin(fPhi); }

   Scalar Mag2() const { return fRho*fRho + fZ*fZ; }
   Scalar R() const { using std::sqrt; return sqrt(Mag2()); }
   Scalar Perp2() const { return fRho*fRho; }
   Scalar Theta() const { using std::atan2; return (fRho == Scalar(0) && fZ == Scalar(0)) ? Scalar(0) : atan2(fRho, fZ); }


   Scalar Eta() const {
      return Impl::Eta_FromRhoZ( fRho, fZ);
   }







   void SetRho(T rho) {
      fRho = rho;
   }




   void SetZ(T zz) {
      fZ = zz;
   }




   void SetPhi(T phi) {
      fPhi = phi;
      Restrict();
   }




   void SetXYZ(Scalar x, Scalar y, Scalar z);





   void Scale (T a) {
      if (a < 0) {
         Negate();
         a = -a;
      }
      fRho *= a;
      fZ *= a;
   }




   void Negate ( ) {
      fPhi = ( fPhi > 0 ? fPhi - pi() : fPhi + pi() );
      fZ = -fZ;
   }





   template <class CoordSystem >
   Cylindrical3D & operator= ( const CoordSystem & c ) {
      fRho = c.Rho();
      fZ = c.Z();
      fPhi = c.Phi();
      return *this;
   }




   bool operator==(const Cylindrical3D & rhs) const {
      return fRho == rhs.fRho && fZ == rhs.fZ && fPhi == rhs.fPhi;
   }
   bool operator!= (const Cylindrical3D & rhs) const
   {return !(operator==(rhs));}






   T x() const { return X();}
   T y() const { return Y();}
   T z() const { return Z(); }
# 240 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 3
private:

   T fRho;
   T fZ;
   T fPhi;

};

  }

}
# 262 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 3
namespace ROOT {

  namespace Math {

template <class T>
void Cylindrical3D<T>::SetXYZ(Scalar xx, Scalar yy, Scalar zz) {
   *this = Cartesian3D<Scalar>(xx, yy, zz);
}
# 314 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/Cylindrical3D.h" 3
  }

}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PositionVector3Dfwd.h" 1 3







namespace ROOT {

  namespace Math {





     template <class CoordSystem, class Tag>
     class PositionVector3D;

  }
}
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/GenVectorIO.h" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/GenVectorIO.h" 3
namespace ROOT {
namespace Math {

namespace detail {





enum manip_t { open, sep, close, bitforbit };


inline int
  ios_data( int k )
{
  static int const ios_data[4] = { std::ios::xalloc()
                                   , std::ios::xalloc()
                                   , std::ios::xalloc()
                                   , std::ios::xalloc()
                                   };

  return ios_data[k];

}


template< class char_t, class traits_t >
  inline char_t
  get_manip( std::basic_ios<char_t,traits_t> & ios
           , manip_t m
           )
{
  char_t ch = static_cast<char_t>( ios.iword( ios_data(m) ) );
  if( ch ) return ch;

  switch( m )
  { default : return ios.widen( '?' );
    case open : return ios.widen( '(' );
    case close : return ios.widen( ')' );
    case sep : return ios.widen( ',' );
    case bitforbit : return ch;
  }

}


template< class char_t, class traits_t >
  inline void
  set_manip( std::basic_ios<char_t,traits_t> & ios
           , manip_t m
           , char_t ch
           )
{
  ios.iword( ios_data(m) ) = static_cast<long>(ch);

}


template< class char_t >
  class manipulator
{
public:
  explicit
    manipulator( manip_t m
               , char_t ch = 0
               )
    : fMan(m)
    , fChar(ch)
  { }

  template< class traits_t >
    void
    set( std::basic_ios<char_t,traits_t> & ios ) const
  {
    set_manip<char_t>( ios, fMan, fChar );
  }

private:
  manip_t fMan;
  char_t fChar;

};


template< class char_t, class traits_t >
  inline
  std::basic_istream<char_t,traits_t> &
  require_delim( std::basic_istream<char_t,traits_t> & is
               , manip_t m
               )
{
  char_t delim = get_manip( is, m );
  if( std::isspace(delim) ) return is;

  char_t ch;
  is >> ch;
  if( ch != delim )
    is.setstate( std::ios::failbit );

  return is;

}


template< class char_t, class traits_t >
  inline
  std::basic_ostream<char_t,traits_t> &
  operator << ( std::basic_ostream<char_t,traits_t> & os
              , detail::manipulator<char_t> const & manip
              )

{
  manip.set(os);
  return os;

}


template< class char_t, class traits_t >
  inline
  std::basic_istream<char_t,traits_t> &
  operator >> ( std::basic_istream<char_t,traits_t> & is
              , detail::manipulator<char_t> const & manip
              )

{
  manip.set(is);
  return is;

}

}






template< class char_t >
  inline
  detail::manipulator<char_t>
  set_open( char_t ch )
{
  return detail::manipulator<char_t>( detail::open, ch );

}


template< class char_t >
  inline
  detail::manipulator<char_t>
  set_separator( char_t ch )
{
  return detail::manipulator<char_t>( detail::sep, ch );

}


template< class char_t >
  inline
  detail::manipulator<char_t>
  set_close( char_t ch )
{
  return detail::manipulator<char_t>( detail::close, ch );

}


template< class char_t, class traits_t >
  inline
  std::basic_ios<char_t,traits_t> &
  human_readable( std::basic_ios<char_t,traits_t> & ios )
{
  ios.iword( ios_data(detail::bitforbit) ) = 0L;
  return ios;

}


template< class char_t, class traits_t >
  inline
  std::basic_ios<char_t,traits_t> &
  machine_readable( std::basic_ios<char_t,traits_t> & ios )
{
  ios.iword( ios_data(detail::bitforbit) ) = 1L;
  return ios;

}



}
}
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/BitReproducible.h" 1 3
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/BitReproducible.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iomanip" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iomanip" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iomanip" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/quoted_string.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/quoted_string.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __detail {



    template<typename _String, typename _CharT>
      struct _Quoted_string
      {
 static_assert(is_reference<_String>::value
     || is_pointer<_String>::value,
        "String type must be pointer or reference");

 _Quoted_string(_String __str, _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 _String _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };


    template<typename _CharT, typename _Traits>
      struct _Quoted_string<basic_string_view<_CharT, _Traits>, _CharT>
      {
 _Quoted_string(basic_string_view<_CharT, _Traits> __str,
         _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 basic_string_view<_CharT, _Traits> _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };







    template<typename _CharT, typename _Traits>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<const _CharT*, _CharT>& __str)
      {


 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (const _CharT* __c = __str._M_string; *__c; ++__c)
   {
     if (*__c == __str._M_delim || *__c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << *__c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }






    template<typename _CharT, typename _Traits, typename _String>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<_String, _CharT>& __str)
      {


 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (auto __c : __str._M_string)
   {
     if (__c == __str._M_delim || __c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << __c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }







    template<typename _CharT, typename _Traits, typename _Alloc>
      std::basic_istream<_CharT, _Traits>&
      operator>>(std::basic_istream<_CharT, _Traits>& __is,
   const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
          _CharT>& __str)
      {
 _CharT __c;
 __is >> __c;
 if (!__is.good())
   return __is;
 if (__c != __str._M_delim)
   {
     __is.unget();
     __is >> __str._M_string;
     return __is;
   }
 __str._M_string.clear();
 std::ios_base::fmtflags __flags
   = __is.flags(__is.flags() & ~std::ios_base::skipws);
 do
   {
     __is >> __c;
     if (!__is.good())
       break;
     if (__c == __str._M_escape)
       {
  __is >> __c;
  if (!__is.good())
    break;
       }
     else if (__c == __str._M_delim)
       break;
     __str._M_string += __c;
   }
 while (true);
 __is.setf(__flags);

 return __is;
      }
  }


}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iomanip" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{





  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 105 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 136 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 173 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/iomanip" 3
  template<typename _CharT>
    inline _Setfill<_CharT>
    setfill(_CharT __c)
    { return { __c }; }

  template<typename _CharT, typename _Traits>
    __attribute__((__deprecated__("'std::setfill' should only be used with "
      "output streams")))
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };
# 206 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 236 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 269 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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; };
# 316 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 368 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    };
# 423 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
    }
# 470 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }
# 519 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);




}

#pragma GCC diagnostic pop
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/BitReproducible.h" 2 3

namespace ROOT {
 namespace Math {
  namespace GenVector_detail {

class BitReproducibleException : public std::exception
{
public:
  BitReproducibleException(const std::string & w) noexcept : fMsg(w) {}
  ~BitReproducibleException() noexcept override {}
  const char *what() const noexcept override { return fMsg.c_str(); }
  private:
  std::string fMsg;
};

class BitReproducible {
public:







  static void Dto2longs(double d, unsigned int & i1, unsigned int & i2);







  static double Longs2double (unsigned int i1, unsigned int i2);





  static std::string D2x(double d);

  static void Output ( std::ostream & os, double d ) {
    unsigned int i1, i2;
    Dto2longs(d, i1, i2);
    os << " " << i1 << " " << i2;
  }

  static void Input ( std::istream & is, double & d ) {
    unsigned int i1, i2;
    is >> i1 >> i2;
    d = Longs2double(i1, i2);
  }

  static void Output ( std::ostream & os, float f ) {
    unsigned int i1, i2;
    Dto2longs( double(f), i1, i2 );
    os << " " << i1 << " " << i2;
  }

  static void Input ( std::istream & is, float & f ) {
    unsigned int i1, i2;
    is >> i1 >> i2;
    f = float( Longs2double(i1, i2) );
  }


private:
  union DB8 {
    unsigned char fB[8];
    double fD;
  };
  static void Fill_byte_order ();
  static bool fgByte_order_known;
  static int fgByte_order[8];







};

}
}
}
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CoordinateSystemTags.h" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CoordinateSystemTags.h" 3
namespace ROOT {

namespace Math {
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CoordinateSystemTags.h" 3
   class DefaultCoordinateSystemTag {};
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CoordinateSystemTags.h" 3
   class GlobalCoordinateSystemTag {};
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/CoordinateSystemTags.h" 3
   class LocalCoordinateSystemTag {};


}

}
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/cassert" 2 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 2 3


namespace ROOT {

  namespace Math {
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
    template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
    class DisplacementVector3D {

    public:

      typedef typename CoordSystem::Scalar Scalar;
      typedef CoordSystem CoordinateType;
      typedef Tag CoordinateSystemTag;






      constexpr DisplacementVector3D ( ) : fCoordinates() { }







      constexpr DisplacementVector3D(Scalar a, Scalar b, Scalar c) :
        fCoordinates ( a , b, c ) { }





      template <class OtherCoords>
      explicit constexpr DisplacementVector3D( const DisplacementVector3D<OtherCoords, Tag> & v) :
        fCoordinates ( v.Coordinates() ) { }






      template <class OtherCoords>
      explicit constexpr DisplacementVector3D( const PositionVector3D<OtherCoords,Tag> & p) :
        fCoordinates ( p.Coordinates() ) { }






      template <class ForeignVector>
      explicit constexpr DisplacementVector3D( const ForeignVector & v) :
        fCoordinates ( Cartesian3D<Scalar>( v.x(), v.y(), v.z() ) ) { }
# 131 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
      template <class OtherCoords>
      DisplacementVector3D & operator=
                        ( const DisplacementVector3D<OtherCoords, Tag> & v) {
        fCoordinates = v.Coordinates();
        return *this;
      }





      template <class OtherCoords>
      DisplacementVector3D & operator=
                        ( const PositionVector3D<OtherCoords,Tag> & rhs) {
         SetXYZ(rhs.x(), rhs.y(), rhs.z());
         return *this;
      }






      template <class ForeignVector>
      DisplacementVector3D & operator= ( const ForeignVector & v) {
        SetXYZ( v.x(), v.y(), v.z() );
        return *this;
      }
# 182 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
      CoordSystem Coordinates() const {
        return fCoordinates;
      }




      DisplacementVector3D<CoordSystem, Tag>& SetCoordinates( const Scalar src[] )
       { fCoordinates.SetCoordinates(src); return *this; }




      DisplacementVector3D<CoordSystem, Tag>& SetCoordinates( Scalar a, Scalar b, Scalar c )
       { fCoordinates.SetCoordinates(a, b, c); return *this; }




      template <class IT>
      DisplacementVector3D<CoordSystem, Tag>& SetCoordinates( IT begin, IT end )
      { IT a = begin; IT b = ++begin; IT c = ++begin;
        (void)end;
        (static_cast <bool> (++begin==end) ? void (0) : __assert_fail ("++begin==end", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h", 205, __extension__ __PRETTY_FUNCTION__));
        SetCoordinates (*a,*b,*c);
        return *this;
      }




      void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
                            { fCoordinates.GetCoordinates(a, b, c); }




      void GetCoordinates( Scalar dest[] ) const
                            { fCoordinates.GetCoordinates(dest); }




      template <class IT>
      void GetCoordinates( IT begin, IT end ) const
      { IT a = begin; IT b = ++begin; IT c = ++begin;
        (void)end;
        (static_cast <bool> (++begin==end) ? void (0) : __assert_fail ("++begin==end", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h", 229, __extension__ __PRETTY_FUNCTION__));
        GetCoordinates (*a,*b,*c);
      }



      template <class IT>
      void GetCoordinates( IT begin) const {
         Scalar a = Scalar(0);
         Scalar b = Scalar(0);
         Scalar c = Scalar(0);
         GetCoordinates(a, b, c);
         *begin++ = a;
         *begin++ = b;
         *begin = c;
      }






      DisplacementVector3D<CoordSystem, Tag>& SetXYZ (Scalar a, Scalar b, Scalar c) {
         fCoordinates.SetXYZ(a, b, c);
         return *this;
      }






      bool operator==(const DisplacementVector3D & rhs) const {
        return fCoordinates==rhs.fCoordinates;
      }
      bool operator!= (const DisplacementVector3D & rhs) const {
        return !(operator==(rhs));
      }






      unsigned int Dimension() const
      {
         return fDimension;
      };




      Scalar X() const { return fCoordinates.X(); }




      Scalar Y() const { return fCoordinates.Y(); }




      Scalar Z() const { return fCoordinates.Z(); }




      Scalar R() const { return fCoordinates.R(); }




      Scalar Theta() const { return fCoordinates.Theta(); }




      Scalar Phi() const { return fCoordinates.Phi(); }




      Scalar Eta() const { return fCoordinates.Eta(); }




      Scalar Rho() const { return fCoordinates.Rho(); }






      Scalar Mag2() const { return fCoordinates.Mag2();}




      Scalar Perp2() const { return fCoordinates.Perp2();}




      template <typename SCALAR = Scalar, typename std::enable_if<std::is_arithmetic<SCALAR>::value>::type * = nullptr>
      DisplacementVector3D Unit() const
      {
         const auto tot = R();
         return tot == 0 ? *this : DisplacementVector3D(*this) / tot;
      }




      template <typename SCALAR = Scalar, typename std::enable_if<!std::is_arithmetic<SCALAR>::value>::type * = nullptr>
      DisplacementVector3D Unit() const
      {
         SCALAR tot = R();
         tot(tot == SCALAR(0)) = SCALAR(1);
         return DisplacementVector3D(*this) / tot;
      }






       DisplacementVector3D<CoordSystem, Tag>& SetX (Scalar xx) { fCoordinates.SetX(xx); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetY (Scalar yy) { fCoordinates.SetY(yy); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetZ (Scalar zz) { fCoordinates.SetZ(zz); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetR (Scalar rr) { fCoordinates.SetR(rr); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetTheta (Scalar ang) { fCoordinates.SetTheta(ang); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetPhi (Scalar ang) { fCoordinates.SetPhi(ang); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetRho (Scalar rr) { fCoordinates.SetRho(rr); return *this;}




       DisplacementVector3D<CoordSystem, Tag>& SetEta (Scalar etaval) { fCoordinates.SetEta(etaval); return *this;}
# 402 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
      template< class OtherCoords >
      Scalar Dot( const DisplacementVector3D<OtherCoords,Tag> & v) const {
        return X()*v.X() + Y()*v.Y() + Z()*v.Z();
      }





      template< class OtherVector >
      Scalar Dot( const OtherVector & v) const {
        return X()*v.x() + Y()*v.y() + Z()*v.z();
      }







      template <class OtherCoords>
      DisplacementVector3D Cross( const DisplacementVector3D<OtherCoords,Tag> & v) const {
        DisplacementVector3D result;
        result.SetXYZ ( Y()*v.Z() - v.Y()*Z(),
                         Z()*v.X() - v.Z()*X(),
                         X()*v.Y() - v.X()*Y() );
        return result;
      }






      template <class OtherVector>
      DisplacementVector3D Cross( const OtherVector & v) const {
        DisplacementVector3D result;
        result.SetXYZ ( Y()*v.z() - v.y()*Z(),
                         Z()*v.x() - v.z()*X(),
                         X()*v.y() - v.x()*Y() );
        return result;
      }






      template <class OtherCoords>
      DisplacementVector3D & operator+=
                        (const DisplacementVector3D<OtherCoords,Tag> & v) {
        SetXYZ( X() + v.X(), Y() + v.Y(), Z() + v.Z() );
        return *this;
      }




      template <class OtherCoords>
      DisplacementVector3D & operator-=
                        (const DisplacementVector3D<OtherCoords,Tag> & v) {
        SetXYZ( x() - v.x(), y() - v.y(), z() - v.z() );
        return *this;
      }





      DisplacementVector3D & operator*= (Scalar a) {
        fCoordinates.Scale(a);
        return *this;
      }




      DisplacementVector3D & operator/= (Scalar a) {
        fCoordinates.Scale(1/a);
        return *this;
      }







      DisplacementVector3D operator * ( Scalar a ) const {
        DisplacementVector3D tmp(*this);
        tmp *= a;
        return tmp;
      }




      DisplacementVector3D operator - ( ) const {
        return operator*( Scalar(-1) );
      }




      DisplacementVector3D operator + ( ) const {return *this;}




      DisplacementVector3D operator/ (Scalar a) const {
        DisplacementVector3D tmp(*this);
        tmp /= a;
        return tmp;
      }




      Scalar x() const { return fCoordinates.X(); }
      Scalar y() const { return fCoordinates.Y(); }
      Scalar z() const { return fCoordinates.Z(); }
      Scalar r() const { return fCoordinates.R(); }
      Scalar theta() const { return fCoordinates.Theta(); }
      Scalar phi() const { return fCoordinates.Phi(); }
      Scalar eta() const { return fCoordinates.Eta(); }
      Scalar rho() const { return fCoordinates.Rho(); }
      Scalar mag2() const { return fCoordinates.Mag2(); }
      Scalar perp2() const { return fCoordinates.Perp2(); }
      DisplacementVector3D unit() const {return Unit();}


    private:

       CoordSystem fCoordinates;
       static constexpr unsigned int fDimension = CoordinateType::Dimension;
# 549 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
      template <class OtherCoords, class OtherTag>
      explicit constexpr DisplacementVector3D( const DisplacementVector3D<OtherCoords, OtherTag> & ) {}

      template <class OtherCoords, class OtherTag>
      explicit constexpr DisplacementVector3D( const PositionVector3D<OtherCoords, OtherTag> & ) {}

      template <class OtherCoords, class OtherTag>
      DisplacementVector3D & operator=( const DisplacementVector3D<OtherCoords, OtherTag> & );


      template <class OtherCoords, class OtherTag>
      DisplacementVector3D & operator=( const PositionVector3D<OtherCoords, OtherTag> & );

      template <class OtherCoords, class OtherTag>
      DisplacementVector3D & operator+=(const DisplacementVector3D<OtherCoords, OtherTag> & );

      template <class OtherCoords, class OtherTag>
      DisplacementVector3D & operator-=(const DisplacementVector3D<OtherCoords, OtherTag> & );

      template<class OtherCoords, class OtherTag >
      Scalar Dot( const DisplacementVector3D<OtherCoords, OtherTag> & ) const;

      template<class OtherCoords, class OtherTag >
      DisplacementVector3D Cross( const DisplacementVector3D<OtherCoords, OtherTag> & ) const;


    };
# 587 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
    template <class CoordSystem1, class CoordSystem2, class U>
    inline
    DisplacementVector3D<CoordSystem1,U>
    operator+( DisplacementVector3D<CoordSystem1,U> v1,
               const DisplacementVector3D<CoordSystem2,U> & v2) {
      return v1 += v2;
    }






    template <class CoordSystem1, class CoordSystem2, class U>
    inline
    DisplacementVector3D<CoordSystem1,U>
    operator-( DisplacementVector3D<CoordSystem1,U> v1,
               DisplacementVector3D<CoordSystem2,U> const & v2) {
      return v1 -= v2;
    }




    template <class CoordSystem, class U>
    inline
    DisplacementVector3D<CoordSystem,U>
    operator * ( typename DisplacementVector3D<CoordSystem,U>::Scalar a,
                 DisplacementVector3D<CoordSystem,U> v) {
      return v *= a;


    }
# 629 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/DisplacementVector3D.h" 3
    template <class char_t, class traits_t, class T, class U,
              typename std::enable_if<std::is_arithmetic<typename DisplacementVector3D<T, U>::Scalar>::value>::type * =
                 nullptr>
    std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
                                                     DisplacementVector3D<T, U> const &v)
    {
       if (os) {

          typename T::Scalar a, b, c;
          v.GetCoordinates(a, b, c);

          if (detail::get_manip(os, detail::bitforbit)) {
             detail::set_manip(os, detail::bitforbit, '\00');
             typedef GenVector_detail::BitReproducible BR;
             BR::Output(os, a);
             BR::Output(os, b);
             BR::Output(os, c);
          } else {
             os << detail::get_manip(os, detail::open) << a << detail::get_manip(os, detail::sep) << b
                << detail::get_manip(os, detail::sep) << c << detail::get_manip(os, detail::close);
          }
      }
      return os;
    }

    template <class char_t, class traits_t, class T, class U,
              typename std::enable_if<!std::is_arithmetic<typename DisplacementVector3D<T, U>::Scalar>::value>::type * =
                 nullptr>
    std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
                                                     DisplacementVector3D<T, U> const &v)
    {
       if (os) {
          os << "{ ";
          for (std::size_t i = 0; i < PositionVector3D<T, U>::Scalar::Size; ++i) {
             os << "(" << v.x()[i] << "," << v.y()[i] << "," << v.z()[i] << ") ";
          }
          os << "}";
       }
       return os;
    }

    template< class char_t, class traits_t, class T, class U >
      inline
      std::basic_istream<char_t,traits_t> &
      operator >> ( std::basic_istream<char_t,traits_t> & is
                  , DisplacementVector3D<T,U> & v
                  )
    {
      if( !is ) return is;

      typename T::Scalar a, b, c;

      if( detail::get_manip( is, detail::bitforbit ) ) {
        detail::set_manip( is, detail::bitforbit, '\00' );
        typedef GenVector_detail::BitReproducible BR;
        BR::Input(is, a);
        BR::Input(is, b);
        BR::Input(is, c);
      }
      else {
        detail::require_delim( is, detail::open ); is >> a;
        detail::require_delim( is, detail::sep ); is >> b;
        detail::require_delim( is, detail::sep ); is >> c;
        detail::require_delim( is, detail::close );
      }

      if( is )
        v.SetCoordinates(a, b, c);
      return is;

    }



  }

}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector3D.h" 2 3
# 17 "include/mdst/dataobjects/MCParticle.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 1 3








# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 1 3
# 21 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
namespace ROOT {

  namespace Math {




    template<class CoordSystem> class LorentzVector;

    template<typename T> class PxPyPzE4D;
    template<typename T> class PtEtaPhiE4D;
    template<typename T> class PxPyPzM4D;
    template<typename T> class PtEtaPhiM4D;
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
    typedef LorentzVector<PxPyPzE4D<double> > XYZTVector;

    typedef LorentzVector<PxPyPzE4D<double> > PxPyPzEVector;
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
    typedef LorentzVector< PxPyPzE4D <float> > XYZTVectorF;
# 66 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
    typedef LorentzVector<PxPyPzM4D<double> > PxPyPzMVector;
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
    typedef LorentzVector<PtEtaPhiE4D<double> > PtEtaPhiEVector;
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4Dfwd.h" 3
    typedef LorentzVector<PtEtaPhiM4D<double> > PtEtaPhiMVector;

  }

}
# 10 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 1 3
# 23 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/GenVector_exception.h" 1 3
# 19 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/GenVector_exception.h" 3
namespace ROOT {
namespace Math {

class GenVector_exception;
inline void Throw(GenVector_exception &e);
namespace GenVector {
inline void Throw(const char *);
}
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/GenVector_exception.h" 3
class GenVector_exception : public std::runtime_error {
public:
   GenVector_exception(const std::string &s) : runtime_error(s) {}




   static bool EnableThrow()
   {
      bool tmp = GenVector_exception::IsOn();
      IsOn() = true;
      return tmp;
   }
   static bool DisableThrow()
   {
      bool tmp = GenVector_exception::IsOn();
      IsOn() = false;
      return tmp;
   }

private:
   friend void Throw(GenVector_exception &);
   friend void GenVector::Throw(const char *);

   static bool &IsOn()
   {
      static bool isOn = false;
      return isOn;
   };

};





inline void Throw(GenVector_exception &e)
{
   if (GenVector_exception::IsOn())
      throw e;
}

namespace GenVector {

inline void Throw(const char *s)
{
   if (!GenVector_exception::IsOn())
      return;
   GenVector_exception e(s);
   throw e;
}
}

}
}
# 24 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 2 3




namespace ROOT {

namespace Math {
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 3
template <class ScalarType = double>
class PxPyPzE4D {

public :

   typedef ScalarType Scalar;
   static constexpr unsigned int Dimension = 4U;






   PxPyPzE4D() : fX(0.0), fY(0.0), fZ(0.0), fT(0.0) { }





   PxPyPzE4D(Scalar px, Scalar py, Scalar pz, Scalar e) :
      fX(px), fY(py), fZ(pz), fT(e) { }






   template <class CoordSystem>
   explicit constexpr PxPyPzE4D(const CoordSystem & v) :
      fX( v.x() ), fY( v.y() ), fZ( v.z() ), fT( v.t() ) { }






   PxPyPzE4D(const PxPyPzE4D & v) :
      fX(v.fX), fY(v.fY), fZ(v.fZ), fT(v.fT) { }




   PxPyPzE4D & operator = (const PxPyPzE4D & v) {
      fX = v.fX;
      fY = v.fY;
      fZ = v.fZ;
      fT = v.fT;
      return *this;
   }




   void SetCoordinates( const Scalar src[] )
   { fX=src[0]; fY=src[1]; fZ=src[2]; fT=src[3]; }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fT; }




   void SetCoordinates(Scalar px, Scalar py, Scalar pz, Scalar e)
   { fX=px; fY=py; fZ=pz; fT=e;}




   void GetCoordinates(Scalar& px, Scalar& py, Scalar& pz, Scalar& e) const
   { px=fX; py=fY; pz=fZ; e=fT;}





   Scalar Px() const { return fX;}
   Scalar Py() const { return fY;}
   Scalar Pz() const { return fZ;}
   Scalar E() const { return fT;}

   Scalar X() const { return fX;}
   Scalar Y() const { return fY;}
   Scalar Z() const { return fZ;}
   Scalar T() const { return fT;}






   Scalar P2() const { return fX*fX + fY*fY + fZ*fZ; }




   Scalar P() const { using std::sqrt; return sqrt(P2()); }
   Scalar R() const { return P(); }




   Scalar M2() const { return fT*fT - fX*fX - fY*fY - fZ*fZ;}
   Scalar Mag2() const { return M2(); }




   Scalar M() const
   {
      const Scalar mm = M2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PxPyPzE4D::M() - Tachyonic:\n"
                   "    P^2 > E^2 so the mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }
   Scalar Mag() const { return M(); }




   Scalar Pt2() const { return fX*fX + fY*fY;}
   Scalar Perp2() const { return Pt2();}




   Scalar Pt() const { using std::sqrt; return sqrt(Perp2()); }
   Scalar Perp() const { return Pt();}
   Scalar Rho() const { return Pt();}




   Scalar Mt2() const { return fT*fT - fZ*fZ; }




   Scalar Mt() const {
      const Scalar mm = Mt2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PxPyPzE4D::Mt() - Tachyonic:\n"
                           "    Pz^2 > E^2 so the transverse mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }




   Scalar Et2() const {

      Scalar pt2 = Pt2();
      return pt2 == 0 ? 0 : fT*fT * pt2/( pt2 + fZ*fZ );
   }




   Scalar Et() const {
      const Scalar etet = Et2();
      using std::sqrt;
      return fT < 0.0 ? -sqrt(etet) : sqrt(etet);
   }




   Scalar Phi() const { using std::atan2; return (fX == 0.0 && fY == 0.0) ? 0 : atan2(fY, fX); }




   Scalar Theta() const { using std::atan2; return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0 : atan2(Pt(), fZ); }




   Scalar Eta() const {
      return Impl::Eta_FromRhoZ ( Pt(), fZ);
   }







   void SetPx( Scalar px) {
      fX = px;
   }



   void SetPy( Scalar py) {
      fY = py;
   }



   void SetPz( Scalar pz) {
      fZ = pz;
   }



   void SetE( Scalar e) {
      fT = e;
   }




   void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
      fX=px;
      fY=py;
      fZ=pz;
      fT=e;
   }
# 282 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 3
   void Negate( ) { fX = -fX; fY = -fY; fZ = -fZ; fT = -fT;}




   void Scale( const Scalar & a) {
      fX *= a;
      fY *= a;
      fZ *= a;
      fT *= a;
   }





   template <class AnyCoordSystem>
   PxPyPzE4D & operator = (const AnyCoordSystem & v) {
      fX = v.x();
      fY = v.y();
      fZ = v.z();
      fT = v.t();
      return *this;
   }




   bool operator == (const PxPyPzE4D & rhs) const {
      return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ && fT == rhs.fT;
   }
   bool operator != (const PxPyPzE4D & rhs) const {return !(operator==(rhs));}






   Scalar x() const { return fX; }
   Scalar y() const { return fY; }
   Scalar z() const { return fZ; }
   Scalar t() const { return fT; }
# 341 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzE4D.h" 3
private:





   ScalarType fX;
   ScalarType fY;
   ScalarType fZ;
   ScalarType fT;

};

}
}
# 13 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 3
namespace ROOT {

namespace Math {
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 3
template <class ScalarType>
class PtEtaPhiE4D {

public :

   typedef ScalarType Scalar;
   static constexpr unsigned int Dimension = 4U;






   PtEtaPhiE4D() : fPt(0), fEta(0), fPhi(0), fE(0) { }




   PtEtaPhiE4D(Scalar pt, Scalar eta, Scalar phi, Scalar e) :
      fPt(pt), fEta(eta), fPhi(phi), fE(e) { Restrict(); }





   template <class CoordSystem >
   explicit constexpr PtEtaPhiE4D(const CoordSystem & c) :
      fPt(c.Pt()), fEta(c.Eta()), fPhi(c.Phi()), fE(c.E()) { }







   PtEtaPhiE4D(const PtEtaPhiE4D & v) :
      fPt(v.fPt), fEta(v.fEta), fPhi(v.fPhi), fE(v.fE) { }




   PtEtaPhiE4D & operator = (const PtEtaPhiE4D & v) {
      fPt = v.fPt;
      fEta = v.fEta;
      fPhi = v.fPhi;
      fE = v.fE;
      return *this;
   }





   void SetCoordinates( const Scalar src[] )
   { fPt=src[0]; fEta=src[1]; fPhi=src[2]; fE=src[3]; Restrict(); }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fPt; dest[1] = fEta; dest[2] = fPhi; dest[3] = fE; }




   void SetCoordinates(Scalar pt, Scalar eta, Scalar phi, Scalar e)
   { fPt=pt; fEta = eta; fPhi = phi; fE = e; Restrict(); }




   void
   GetCoordinates(Scalar& pt, Scalar & eta, Scalar & phi, Scalar& e) const
   { pt=fPt; eta=fEta; phi = fPhi; e = fE; }





   Scalar Pt() const { return fPt; }
   Scalar Eta() const { return fEta; }
   Scalar Phi() const { return fPhi; }
   Scalar E() const { return fE; }

   Scalar Perp()const { return Pt(); }
   Scalar Rho() const { return Pt(); }
   Scalar T() const { return E(); }



   Scalar Px() const { using std::cos; return fPt * cos(fPhi); }
   Scalar X () const { return Px(); }
   Scalar Py() const { using std::sin; return fPt * sin(fPhi); }
   Scalar Y () const { return Py(); }
   Scalar Pz() const {
      using std:: sinh;
      return fPt > 0 ? fPt * sinh(fEta) : fEta == 0 ? 0 : fEta > 0 ? fEta - etaMax<Scalar>() : fEta + etaMax<Scalar>();
   }
   Scalar Z () const { return Pz(); }




   Scalar P() const {
     using std::cosh;
      return fPt > 0 ? fPt * cosh(fEta)
                     : fEta > etaMax<Scalar>() ? fEta - etaMax<Scalar>()
                                               : fEta < -etaMax<Scalar>() ? -fEta - etaMax<Scalar>() : 0;
   }
   Scalar R() const { return P(); }




   Scalar P2() const
   {
      const Scalar p = P();
      return p * p;
   }




   Scalar M2() const
   {
      const Scalar p = P();
      return fE * fE - p * p;
   }
   Scalar Mag2() const { return M2(); }




   Scalar M() const {
      const Scalar mm = M2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PtEtaPhiE4D::M() - Tachyonic:\n"
                           "    Pt and Eta give P such that P^2 > E^2, so the mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }
   Scalar Mag() const { return M(); }




   Scalar Pt2() const { return fPt*fPt;}
   Scalar Perp2() const { return Pt2(); }




   Scalar Mt2() const { Scalar pz = Pz(); return fE*fE - pz*pz; }




   Scalar Mt() const {
      const Scalar mm = Mt2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PtEtaPhiE4D::Mt() - Tachyonic:\n"
                           "    Pt and Eta give Pz such that Pz^2 > E^2, so the mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }







   Scalar Et() const {
      using std::cosh;
      return fE / cosh(fEta);
   }




   Scalar Et2() const
   {
      const Scalar et = Et();
      return et * et;
   }

private:
   inline static Scalar pi() { return 3.14159265358979323846; }
   inline void Restrict() {
      using std::floor;
      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
   }
public:




   Scalar Theta() const { using std::atan; return (fPt > 0 ? Scalar(2) * atan(exp(-fEta)) : fEta >= 0 ? 0 : pi()); }






   void SetPt( Scalar pt) {
      fPt = pt;
   }



   void SetEta( Scalar eta) {
      fEta = eta;
   }



   void SetPhi( Scalar phi) {
      fPhi = phi;
      Restrict();
   }



   void SetE( Scalar e) {
      fE = e;
   }




   void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e);







   void Negate( ) {
      fPhi = ( fPhi > 0 ? fPhi - pi() : fPhi + pi() );
      fEta = - fEta;
      fE = - fE;
   }




   void Scale( Scalar a) {
      if (a < 0) {
         Negate(); a = -a;
      }
      fPt *= a;
      fE *= a;
   }





   template <class CoordSystem >
   PtEtaPhiE4D & operator = (const CoordSystem & c) {
      fPt = c.Pt();
      fEta = c.Eta();
      fPhi = c.Phi();
      fE = c.E();
      return *this;
   }




   bool operator == (const PtEtaPhiE4D & rhs) const {
      return fPt == rhs.fPt && fEta == rhs.fEta
         && fPhi == rhs.fPhi && fE == rhs.fE;
   }
   bool operator != (const PtEtaPhiE4D & rhs) const {return !(operator==(rhs));}





   Scalar x() const { return X(); }
   Scalar y() const { return Y(); }
   Scalar z() const { return Z(); }
   Scalar t() const { return E(); }
# 364 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 3
private:

   ScalarType fPt;
   ScalarType fEta;
   ScalarType fPhi;
   ScalarType fE;

};


}
}
# 385 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 3
namespace ROOT {

namespace Math {

template <class ScalarType>
inline void PtEtaPhiE4D<ScalarType>::SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
   *this = PxPyPzE4D<Scalar> (px, py, pz, e);
}
# 427 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiE4D.h" 3
}

}
# 14 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 1 3
# 28 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 3
namespace ROOT {

namespace Math {
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 3
template <class ScalarType = double>
class PxPyPzM4D {

public :

   typedef ScalarType Scalar;
   static constexpr unsigned int Dimension = 4U;






   PxPyPzM4D() : fX(0.0), fY(0.0), fZ(0.0), fM(0.0) { }





   PxPyPzM4D(Scalar px, Scalar py, Scalar pz, Scalar m) :
      fX(px), fY(py), fZ(pz), fM(m) {

      if (fM < 0) RestrictNegMass();
   }





   template <class CoordSystem>
   explicit constexpr PxPyPzM4D(const CoordSystem & v) :
      fX( v.X() ), fY( v.Y() ), fZ( v.Z() ), fM( v.M() )
   { }






   PxPyPzM4D(const PxPyPzM4D & v) :
      fX(v.fX), fY(v.fY), fZ(v.fZ), fM(v.fM) { }




   PxPyPzM4D & operator = (const PxPyPzM4D & v) {
      fX = v.fX;
      fY = v.fY;
      fZ = v.fZ;
      fM = v.fM;
      return *this;
   }






   template <class AnyCoordSystem>
   PxPyPzM4D & operator = (const AnyCoordSystem & v) {
      fX = v.X();
      fY = v.Y();
      fZ = v.Z();
      fM = v.M();
      return *this;
   }




   void SetCoordinates( const Scalar src[] ) {
      fX=src[0]; fY=src[1]; fZ=src[2]; fM=src[3];
      if (fM < 0) RestrictNegMass();
   }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fM; }




   void SetCoordinates(Scalar px, Scalar py, Scalar pz, Scalar m) {
      fX=px; fY=py; fZ=pz; fM=m;
      if (fM < 0) RestrictNegMass();
   }




   void GetCoordinates(Scalar& px, Scalar& py, Scalar& pz, Scalar& m) const
   { px=fX; py=fY; pz=fZ; m=fM;}





   Scalar Px() const { return fX;}
   Scalar Py() const { return fY;}
   Scalar Pz() const { return fZ;}
   Scalar M() const { return fM; }

   Scalar X() const { return fX;}
   Scalar Y() const { return fY;}
   Scalar Z() const { return fZ;}





   Scalar E() const { using std::sqrt; return sqrt(E2()); }

   Scalar T() const { return E();}




   Scalar P2() const { return fX*fX + fY*fY + fZ*fZ; }




   Scalar P() const { using std::sqrt; return sqrt(P2()); }
   Scalar R() const { return P(); }





   Scalar M2() const {
      return ( fM >= 0 ) ? fM*fM : -fM*fM;
   }
   Scalar Mag2() const { return M2(); }

   Scalar Mag() const { return M(); }




   Scalar E2() const {
      Scalar e2 = P2() + M2();

      return e2 > 0 ? e2 : 0;
   }




   Scalar Pt2() const { return fX*fX + fY*fY;}
   Scalar Perp2() const { return Pt2();}




   Scalar Pt() const { using std::sqrt; return sqrt(Perp2()); }
   Scalar Perp() const { return Pt();}
   Scalar Rho() const { return Pt();}




   Scalar Mt2() const { return E2() - fZ*fZ; }




   Scalar Mt() const {
      const Scalar mm = Mt2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PxPyPzM4D::Mt() - Tachyonic:\n"
                           "    Pz^2 > E^2 so the transverse mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }




   Scalar Et2() const {

      Scalar pt2 = Pt2();
      return pt2 == 0 ? 0 : E2() * pt2/( pt2 + fZ*fZ );
   }




   Scalar Et() const {
      const Scalar etet = Et2();
      using std::sqrt;
      return sqrt(etet);
   }




   Scalar Phi() const { using std::atan2; return (fX == 0.0 && fY == 0.0) ? 0.0 : atan2(fY, fX); }




   Scalar Theta() const { using std::atan2; return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0 : atan2(Pt(), fZ); }




   Scalar Eta() const {
      return Impl::Eta_FromRhoZ ( Pt(), fZ);
   }







   void SetPx( Scalar px) {
      fX = px;
   }



   void SetPy( Scalar py) {
      fY = py;
   }



   void SetPz( Scalar pz) {
      fZ = pz;
   }



   void SetM( Scalar m) {
      fM = m;
      if (fM < 0) RestrictNegMass();
   }




   void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e);
# 305 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 3
   void Negate( ) {
      fX = -fX;
      fY = -fY;
      fZ = -fZ;
      GenVector::Throw ("PxPyPzM4D::Negate - cannot negate the energy - can negate only the spatial components");
   }




   void Scale( const Scalar & a) {
      fX *= a;
      fY *= a;
      fZ *= a;
      fM *= a;
   }





   bool operator == (const PxPyPzM4D & rhs) const {
      return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ && fM == rhs.fM;
   }
   bool operator != (const PxPyPzM4D & rhs) const {return !(operator==(rhs));}






   Scalar x() const { return X(); }
   Scalar y() const { return Y(); }
   Scalar z() const { return Z(); }
   Scalar t() const { return E(); }
# 357 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 3
private:



   inline void RestrictNegMass() {
      if ( fM >=0 ) return;
      if ( P2() - fM*fM < 0 ) {
         GenVector::Throw("PxPyPzM4D::unphysical value of mass, set to closest physical value");
         fM = - P();
      }
      return;
   }






   ScalarType fX;
   ScalarType fY;
   ScalarType fZ;
   ScalarType fM;

};

}
}





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 3
namespace ROOT {

namespace Math {
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 3
template <class ScalarType>
class PtEtaPhiM4D {

public :

   typedef ScalarType Scalar;
   static constexpr unsigned int Dimension = 4U;






   PtEtaPhiM4D() : fPt(0), fEta(0), fPhi(0), fM(0) { }




   PtEtaPhiM4D(Scalar pt, Scalar eta, Scalar phi, Scalar mass) :
      fPt(pt), fEta(eta), fPhi(phi), fM(mass) {
      RestrictPhi();
      if (fM < 0) RestrictNegMass();
   }





   template <class CoordSystem >
   explicit constexpr PtEtaPhiM4D(const CoordSystem & c) :
      fPt(c.Pt()), fEta(c.Eta()), fPhi(c.Phi()), fM(c.M()) { RestrictPhi(); }







   PtEtaPhiM4D(const PtEtaPhiM4D & v) :
      fPt(v.fPt), fEta(v.fEta), fPhi(v.fPhi), fM(v.fM) { }




   PtEtaPhiM4D & operator = (const PtEtaPhiM4D & v) {
      fPt = v.fPt;
      fEta = v.fEta;
      fPhi = v.fPhi;
      fM = v.fM;
      return *this;
   }





   void SetCoordinates( const Scalar src[] ) {
      fPt=src[0]; fEta=src[1]; fPhi=src[2]; fM=src[3];
      RestrictPhi();
      if (fM <0) RestrictNegMass();
   }




   void GetCoordinates( Scalar dest[] ) const
   { dest[0] = fPt; dest[1] = fEta; dest[2] = fPhi; dest[3] = fM; }




   void SetCoordinates(Scalar pt, Scalar eta, Scalar phi, Scalar mass) {
      fPt=pt; fEta = eta; fPhi = phi; fM = mass;
      RestrictPhi();
      if (fM <0) RestrictNegMass();
   }




   void
   GetCoordinates(Scalar& pt, Scalar & eta, Scalar & phi, Scalar& mass) const
   { pt=fPt; eta=fEta; phi = fPhi; mass = fM; }





   Scalar Pt() const { return fPt; }
   Scalar Eta() const { return fEta; }
   Scalar Phi() const { return fPhi; }




   Scalar M() const { return fM; }
   Scalar Mag() const { return M(); }

   Scalar Perp()const { return Pt(); }
   Scalar Rho() const { return Pt(); }



   Scalar Px() const { using std::cos; return fPt * cos(fPhi); }
   Scalar X () const { return Px(); }
   Scalar Py() const { using std::sin; return fPt * sin(fPhi); }
   Scalar Y () const { return Py(); }
   Scalar Pz() const {
      using std::sinh;
      return fPt > 0 ? fPt * sinh(fEta) : fEta == 0 ? 0 : fEta > 0 ? fEta - etaMax<Scalar>() : fEta + etaMax<Scalar>();
   }
   Scalar Z () const { return Pz(); }




   Scalar P() const {
      using std::cosh;
      return fPt > 0 ? fPt * cosh(fEta)
                     : fEta > etaMax<Scalar>() ? fEta - etaMax<Scalar>()
                                               : fEta < -etaMax<Scalar>() ? -fEta - etaMax<Scalar>() : 0;
   }
   Scalar R() const { return P(); }




   Scalar P2() const
   {
      const Scalar p = P();
      return p * p;
   }




   Scalar E2() const {
      Scalar e2 = P2() + M2();

      return e2 > 0 ? e2 : 0;
   }




   Scalar E() const { using std::sqrt; return sqrt(E2()); }

   Scalar T() const { return E(); }





   Scalar M2() const {
      return ( fM >= 0 ) ? fM*fM : -fM*fM;
   }
   Scalar Mag2() const { return M2(); }




   Scalar Pt2() const { return fPt*fPt;}
   Scalar Perp2() const { return Pt2(); }




   Scalar Mt2() const { return M2() + fPt*fPt; }




   Scalar Mt() const {
      const Scalar mm = Mt2();
      if (mm >= 0) {
         using std::sqrt;
         return sqrt(mm);
      } else {
         GenVector::Throw ("PtEtaPhiM4D::Mt() - Tachyonic:\n"
                            "    Pz^2 > E^2 so the transverse mass would be imaginary");
         using std::sqrt;
         return -sqrt(-mm);
      }
   }




   Scalar Et2() const {

      using std::cosh;
      return 2. * E2() / (cosh(2 * fEta) + 1);
   }




   Scalar Et() const { using std::cosh; return E() / cosh(fEta); }

private:
   inline static Scalar pi() { return 3.14159265358979323846; }
   inline void RestrictPhi() {
      using std::floor;
      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
   }


   inline void RestrictNegMass() {
      if (fM < 0) {
         if (P2() - fM * fM < 0) {
            GenVector::Throw("PtEtaPhiM4D::unphysical value of mass, set to closest physical value");
            fM = -P();
         }
      }
   }

public:




   Scalar Theta() const { using std::atan; return (fPt > 0 ? Scalar(2) * atan(exp(-fEta)) : fEta >= 0 ? 0 : pi()); }






   void SetPt( Scalar pt) {
      fPt = pt;
   }



   void SetEta( Scalar eta) {
      fEta = eta;
   }



   void SetPhi( Scalar phi) {
      fPhi = phi;
      RestrictPhi();
   }



   void SetM( Scalar mass) {
      fM = mass;
      if (fM <0) RestrictNegMass();
   }




   void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e);
# 318 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 3
   void Negate( ) {
      fPhi = ( (fPhi > 0) ? fPhi - pi() : fPhi + pi() );
      fEta = - fEta;
      GenVector::Throw ("PtEtaPhiM4D::Negate - cannot negate the energy - can negate only the spatial components");
   }




   void Scale( Scalar a) {
      if (a < 0) {
         Negate(); a = -a;
      }
      fPt *= a;
      fM *= a;
   }





   template <class CoordSystem >
   PtEtaPhiM4D & operator = (const CoordSystem & c) {
      fPt = c.Pt();
      fEta = c.Eta();
      fPhi = c.Phi();
      fM = c.M();
      return *this;
   }




   bool operator == (const PtEtaPhiM4D & rhs) const {
      return fPt == rhs.fPt && fEta == rhs.fEta
         && fPhi == rhs.fPhi && fM == rhs.fM;
   }
   bool operator != (const PtEtaPhiM4D & rhs) const {return !(operator==(rhs));}





   Scalar x() const { return X(); }
   Scalar y() const { return Y(); }
   Scalar z() const { return Z(); }
   Scalar t() const { return E(); }
# 381 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 3
private:

   ScalarType fPt;
   ScalarType fEta;
   ScalarType fPhi;
   ScalarType fM;

};


}
}







namespace ROOT {

namespace Math {


template <class ScalarType>
inline void PtEtaPhiM4D<ScalarType>::SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
   *this = PxPyPzE4D<Scalar> (px, py, pz, e);
}
# 442 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PtEtaPhiM4D.h" 3
}

}
# 390 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 2 3

namespace ROOT {

namespace Math {

template <class ScalarType>
inline void PxPyPzM4D<ScalarType>::SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
   *this = PxPyPzE4D<Scalar> (px, py, pz, e);
}
# 436 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/PxPyPzM4D.h" 3
}

}
# 15 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
namespace ROOT {

  namespace Math {
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
    template< class CoordSystem >
    class LorentzVector {

    public:



       typedef typename CoordSystem::Scalar Scalar;
       typedef CoordSystem CoordinateType;




       LorentzVector ( ) : fCoordinates() { }
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       LorentzVector(const Scalar & a,
                     const Scalar & b,
                     const Scalar & c,
                     const Scalar & d) :
          fCoordinates(a , b, c, d) { }





       template< class Coords >
       explicit constexpr LorentzVector(const LorentzVector<Coords> & v ) :
          fCoordinates( v.Coordinates() ) { }





       template<class ForeignLorentzVector,
                typename = decltype(std::declval<ForeignLorentzVector>().x()
                                    + std::declval<ForeignLorentzVector>().y()
                                    + std::declval<ForeignLorentzVector>().z()
                                    + std::declval<ForeignLorentzVector>().t())>
       explicit constexpr LorentzVector( const ForeignLorentzVector & v) :
          fCoordinates(PxPyPzE4D<Scalar>( v.x(), v.y(), v.z(), v.t() ) ) { }
# 129 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       template< class OtherCoords >
       LorentzVector & operator= ( const LorentzVector<OtherCoords> & v) {
          fCoordinates = v.Coordinates();
          return *this;
       }





       template<class ForeignLorentzVector,
                typename = decltype(std::declval<ForeignLorentzVector>().x()
                                    + std::declval<ForeignLorentzVector>().y()
                                    + std::declval<ForeignLorentzVector>().z()
                                    + std::declval<ForeignLorentzVector>().t())>
       LorentzVector & operator = ( const ForeignLorentzVector & v) {
          SetXYZT( v.x(), v.y(), v.z(), v.t() );
          return *this;
       }
# 170 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       const CoordSystem & Coordinates() const {
          return fCoordinates;
       }




       LorentzVector<CoordSystem>& SetCoordinates( const Scalar src[] ) {
          fCoordinates.SetCoordinates(src);
          return *this;
       }




       LorentzVector<CoordSystem>& SetCoordinates( Scalar a, Scalar b, Scalar c, Scalar d ) {
          fCoordinates.SetCoordinates(a, b, c, d);
          return *this;
       }




       template< class IT >
       LorentzVector<CoordSystem>& SetCoordinates( IT begin, IT end ) {
          IT a = begin; IT b = ++begin; IT c = ++begin; IT d = ++begin;
          (void)end;
          (static_cast <bool> (++begin==end) ? void (0) : __assert_fail ("++begin==end", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h", 197, __extension__ __PRETTY_FUNCTION__));
          SetCoordinates (*a,*b,*c,*d);
          return *this;
       }




       void GetCoordinates( Scalar& a, Scalar& b, Scalar& c, Scalar & d ) const
       { fCoordinates.GetCoordinates(a, b, c, d); }




       void GetCoordinates( Scalar dest[] ) const
       { fCoordinates.GetCoordinates(dest); }




       template <class IT>
       void GetCoordinates( IT begin, IT end ) const
       { IT a = begin; IT b = ++begin; IT c = ++begin; IT d = ++begin;
       (void)end;
       (static_cast <bool> (++begin==end) ? void (0) : __assert_fail ("++begin==end", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h", 221, __extension__ __PRETTY_FUNCTION__));
       GetCoordinates (*a,*b,*c,*d);
       }




       template <class IT>
       void GetCoordinates( IT begin ) const {
          Scalar a,b,c,d = 0;
          GetCoordinates (a,b,c,d);
          *begin++ = a;
          *begin++ = b;
          *begin++ = c;
          *begin = d;
       }






       LorentzVector<CoordSystem>& SetXYZT (Scalar xx, Scalar yy, Scalar zz, Scalar tt) {
          fCoordinates.SetPxPyPzE(xx,yy,zz,tt);
          return *this;
       }
       LorentzVector<CoordSystem>& SetPxPyPzE (Scalar xx, Scalar yy, Scalar zz, Scalar ee) {
          fCoordinates.SetPxPyPzE(xx,yy,zz,ee);
          return *this;
       }






       bool operator==(const LorentzVector & rhs) const {
          return fCoordinates==rhs.fCoordinates;
       }
       bool operator!= (const LorentzVector & rhs) const {
          return !(operator==(rhs));
       }






       unsigned int Dimension() const
       {
          return fDimension;
       };






       Scalar Px() const { return fCoordinates.Px(); }
       Scalar X() const { return fCoordinates.Px(); }



       Scalar Py() const { return fCoordinates.Py(); }
       Scalar Y() const { return fCoordinates.Py(); }



       Scalar Pz() const { return fCoordinates.Pz(); }
       Scalar Z() const { return fCoordinates.Pz(); }



       Scalar E() const { return fCoordinates.E(); }
       Scalar T() const { return fCoordinates.E(); }




       Scalar M2() const { return fCoordinates.M2(); }





       Scalar M() const { return fCoordinates.M();}



       Scalar R() const { return fCoordinates.R(); }
       Scalar P() const { return fCoordinates.R(); }



       Scalar P2() const { return P() * P(); }



       Scalar Perp2( ) const { return fCoordinates.Perp2();}




       Scalar Pt() const { return fCoordinates.Pt(); }
       Scalar Rho() const { return fCoordinates.Pt(); }





       Scalar Mt2() const { return fCoordinates.Mt2(); }





       Scalar Mt() const { return fCoordinates.Mt(); }





       Scalar Et2() const { return fCoordinates.Et2(); }





       Scalar Et() const { return fCoordinates.Et(); }




       Scalar Phi() const { return fCoordinates.Phi();}




       Scalar Theta() const { return fCoordinates.Theta(); }





       Scalar Eta() const { return fCoordinates.Eta(); }





       ::ROOT::Math::DisplacementVector3D<Cartesian3D<Scalar> > Vect() const {
          return ::ROOT::Math::DisplacementVector3D<Cartesian3D<Scalar> >( X(), Y(), Z() );
       }
# 386 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       template< class OtherLorentzVector >
       Scalar Dot(const OtherLorentzVector & q) const {
          return t()*q.t() - x()*q.x() - y()*q.y() - z()*q.z();
       }







      template< class OtherLorentzVector >
      inline LorentzVector & operator += ( const OtherLorentzVector & q)
       {
          SetXYZT( x() + q.x(), y() + q.y(), z() + q.z(), t() + q.t() );
          return *this;
       }







       template< class OtherLorentzVector >
       LorentzVector & operator -= ( const OtherLorentzVector & q) {
          SetXYZT( x() - q.x(), y() - q.y(), z() - q.z(), t() - q.t() );
          return *this;
       }
# 423 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       template<class OtherLorentzVector>
       LorentzVector operator + ( const OtherLorentzVector & v2) const
       {
          LorentzVector<CoordinateType> v3(*this);
          v3 += v2;
          return v3;
       }
# 438 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
       template<class OtherLorentzVector>
       LorentzVector operator - ( const OtherLorentzVector & v2) const {
          LorentzVector<CoordinateType> v3(*this);
          v3 -= v2;
          return v3;
       }






       LorentzVector & operator *= (Scalar a) {
          fCoordinates.Scale(a);
          return *this;
       }




       LorentzVector & operator /= (Scalar a) {
          fCoordinates.Scale(1/a);
          return *this;
       }






       LorentzVector operator * ( const Scalar & a) const {
          LorentzVector tmp(*this);
          tmp *= a;
          return tmp;
       }






       LorentzVector<CoordSystem> operator / ( const Scalar & a) const {
          LorentzVector<CoordSystem> tmp(*this);
          tmp /= a;
          return tmp;
       }





       LorentzVector operator - () const {


          return operator*( Scalar(-1) );
       }
       LorentzVector operator + () const {
          return *this;
       }






       Scalar Rapidity() const {



          const Scalar ee = E();
          const Scalar ppz = Pz();
          using std::log;
          return Scalar(0.5) * log((ee + ppz) / (ee - ppz));
       }




       Scalar ColinearRapidity() const {


          const Scalar ee = E();
          const Scalar pp = P();
          using std::log;
          return Scalar(0.5) * log((ee + pp) / (ee - pp));
       }




       bool isTimelike( ) const {
          Scalar ee = E(); Scalar pp = P(); return ee*ee > pp*pp;
       }




       bool isLightlike( Scalar tolerance
                         = 100*std::numeric_limits<Scalar>::epsilon() ) const {
          Scalar ee = E(); Scalar pp = P(); Scalar delta = ee-pp;
          if ( ee==0 ) return pp==0;
          return delta*delta < tolerance * ee*ee;
       }




       bool isSpacelike( ) const {
          Scalar ee = E(); Scalar pp = P(); return ee*ee < pp*pp;
       }

       typedef DisplacementVector3D< Cartesian3D<Scalar> > BetaVector;





       BetaVector BoostToCM( ) const {
          if (E() == 0) {
             if (P() == 0) {
                return BetaVector();
             } else {


                return -Vect()/E();
             }
          }
          if (M2() <= 0) {


          }
          return -Vect()/E();
       }





       template <class Other4Vector>
       BetaVector BoostToCM(const Other4Vector& v ) const {
          Scalar eSum = E() + v.E();
          DisplacementVector3D< Cartesian3D<Scalar> > vecSum = Vect() + v.Vect();
          if (eSum == 0) {
             if (vecSum.Mag2() == 0) {
                return BetaVector();
             } else {


                return BetaVector(vecSum/eSum);
             }


          }
          return BetaVector (vecSum * (-1./eSum));
       }






       Scalar Beta() const {
          if ( E() == 0 ) {
             if ( P2() == 0)

                return 0;
             else {
                GenVector::Throw ("LorentzVector::Beta() - beta computed for LorentzVector with t = 0. Return an Infinite result");
                return 1./E();
             }
          }
          if ( M2() <= 0 ) {
             GenVector::Throw ("LorentzVector::Beta() - beta computed for non-timelike LorentzVector . Result is physically meaningless" );
          }
          return P() / E();
       }



       Scalar Gamma() const {
          const Scalar v2 = P2();
          const Scalar t2 = E() * E();
          if (E() == 0) {
             if ( P2() == 0) {
                return 1;
             } else {
                GenVector::Throw ("LorentzVector::Gamma() - gamma computed for LorentzVector with t = 0. Return a zero result");

             }
          }
          if ( t2 < v2 ) {
             GenVector::Throw ("LorentzVector::Gamma() - gamma computed for a spacelike LorentzVector. Imaginary result");
             return 0;
          }
          else if ( t2 == v2 ) {
             GenVector::Throw ("LorentzVector::Gamma() - gamma computed for a lightlike LorentzVector. Infinite result");
          }
          using std::sqrt;
          return Scalar(1) / sqrt(Scalar(1) - v2 / t2);
       }




       Scalar x() const { return fCoordinates.Px(); }
       Scalar y() const { return fCoordinates.Py(); }
       Scalar z() const { return fCoordinates.Pz(); }
       Scalar t() const { return fCoordinates.E(); }
       Scalar px() const { return fCoordinates.Px(); }
       Scalar py() const { return fCoordinates.Py(); }
       Scalar pz() const { return fCoordinates.Pz(); }
       Scalar e() const { return fCoordinates.E(); }
       Scalar r() const { return fCoordinates.R(); }
       Scalar theta() const { return fCoordinates.Theta(); }
       Scalar phi() const { return fCoordinates.Phi(); }
       Scalar rho() const { return fCoordinates.Rho(); }
       Scalar eta() const { return fCoordinates.Eta(); }
       Scalar pt() const { return fCoordinates.Pt(); }
       Scalar perp2() const { return fCoordinates.Perp2(); }
       Scalar mag2() const { return fCoordinates.M2(); }
       Scalar mag() const { return fCoordinates.M(); }
       Scalar mt() const { return fCoordinates.Mt(); }
       Scalar mt2() const { return fCoordinates.Mt2(); }



       Scalar energy() const { return fCoordinates.E(); }
       Scalar mass() const { return fCoordinates.M(); }
       Scalar mass2() const { return fCoordinates.M2(); }







       LorentzVector<CoordSystem>& SetE ( Scalar a ) { fCoordinates.SetE (a); return *this; }
       LorentzVector<CoordSystem>& SetEta( Scalar a ) { fCoordinates.SetEta(a); return *this; }
       LorentzVector<CoordSystem>& SetM ( Scalar a ) { fCoordinates.SetM (a); return *this; }
       LorentzVector<CoordSystem>& SetPhi( Scalar a ) { fCoordinates.SetPhi(a); return *this; }
       LorentzVector<CoordSystem>& SetPt ( Scalar a ) { fCoordinates.SetPt (a); return *this; }
       LorentzVector<CoordSystem>& SetPx ( Scalar a ) { fCoordinates.SetPx (a); return *this; }
       LorentzVector<CoordSystem>& SetPy ( Scalar a ) { fCoordinates.SetPy (a); return *this; }
       LorentzVector<CoordSystem>& SetPz ( Scalar a ) { fCoordinates.SetPz (a); return *this; }

    private:

       CoordSystem fCoordinates;
       static constexpr unsigned int fDimension = CoordinateType::Dimension;

    };
# 700 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/GenVector/LorentzVector.h" 3
    template< class CoordSystem >
    inline LorentzVector<CoordSystem> operator *
    ( const typename LorentzVector<CoordSystem>::Scalar & a,
      const LorentzVector<CoordSystem>& v) {
       LorentzVector<CoordSystem> tmp(v);
       tmp *= a;
       return tmp;
    }



    template< class char_t, class traits_t, class Coords >
    inline
    std::basic_ostream<char_t,traits_t> &
    operator << ( std::basic_ostream<char_t,traits_t> & os
                  , LorentzVector<Coords> const & v
       )
    {
       if( !os ) return os;

       typename Coords::Scalar a, b, c, d;
       v.GetCoordinates(a, b, c, d);

       if( detail::get_manip( os, detail::bitforbit ) ) {
        detail::set_manip( os, detail::bitforbit, '\00' );

       }
       else {
          os << detail::get_manip( os, detail::open ) << a
             << detail::get_manip( os, detail::sep ) << b
             << detail::get_manip( os, detail::sep ) << c
             << detail::get_manip( os, detail::sep ) << d
             << detail::get_manip( os, detail::close );
       }

       return os;

    }


     template< class char_t, class traits_t, class Coords >
     inline
     std::basic_istream<char_t,traits_t> &
     operator >> ( std::basic_istream<char_t,traits_t> & is
                   , LorentzVector<Coords> & v
        )
     {
        if( !is ) return is;

        typename Coords::Scalar a, b, c, d;

        if( detail::get_manip( is, detail::bitforbit ) ) {
           detail::set_manip( is, detail::bitforbit, '\00' );

        }
        else {
           detail::require_delim( is, detail::open ); is >> a;
           detail::require_delim( is, detail::sep ); is >> b;
           detail::require_delim( is, detail::sep ); is >> c;
           detail::require_delim( is, detail::sep ); is >> d;
           detail::require_delim( is, detail::close );
        }

        if( is )
           v.SetCoordinates(a, b, c, d);
        return is;

     }



  }

}


namespace cling
{
template<typename CoordSystem>
std::string printValue(const ROOT::Math::LorentzVector<CoordSystem> *v)
{
   std::stringstream s;
   s << *v;
   return s.str();
}

}
# 18 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/Math/Vector4D.h" 2 3
# 18 "include/mdst/dataobjects/MCParticle.h" 2






namespace Belle2 {



  class MCParticle: public RelationsObject {
  public:



    class LastChildIndexOutOfRangError : public std::runtime_error { public: LastChildIndexOutOfRangError(): std::runtime_error(""), m_format("Last child index out of range!") { } ~LastChildIndexOutOfRangError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> LastChildIndexOutOfRangError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };

    class NoParticleListSetError : public std::runtime_error { public: NoParticleListSetError(): std::runtime_error(""), m_format("No Particle list set, cannot determine related particles!") { } ~NoParticleListSetError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> NoParticleListSetError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };

    class ParticlePDGNotKnownError : public std::runtime_error { public: ParticlePDGNotKnownError(): std::runtime_error(""), m_format("The pdg value (%1%) of the MCParticle is not known!") { } ~ParticlePDGNotKnownError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> ParticlePDGNotKnownError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };



    enum StatusBit {

      c_PrimaryParticle = 1 << 0,

      c_StableInGenerator = 1 << 1,

      c_LeftDetector = 1 << 2,

      c_StoppedInDetector = 1 << 3,

      c_IsVirtual = 1 << 4,

      c_Initial = 1 << 5,

      c_IsISRPhoton = 1 << 6,

      c_IsFSRPhoton = 1 << 7,

      c_IsPHOTOSPhoton = 1 << 8,

      c_IsRadiativePhoton = c_IsISRPhoton | c_IsFSRPhoton | c_IsPHOTOSPhoton,
    };





    MCParticle() {}
# 78 "include/mdst/dataobjects/MCParticle.h"
    MCParticle(TClonesArray* plist, const MCParticle& p):
      m_plist(plist),
      m_productionTime(p.m_productionTime), m_productionVertex_x(p.m_productionVertex_x),
      m_productionVertex_y(p.m_productionVertex_y), m_productionVertex_z(p.m_productionVertex_z),
      m_decayTime(p.m_decayTime), m_decayVertex_x(p.m_decayVertex_x),
      m_decayVertex_y(p.m_decayVertex_y), m_decayVertex_z(p.m_decayVertex_z),
      m_pdg(p.m_pdg), m_mass(p.m_mass), m_energy(p.m_energy),
      m_momentum_x(p.m_momentum_x), m_momentum_y(p.m_momentum_y), m_momentum_z(p.m_momentum_z),
      m_index(p.m_index),
      m_mother(p.m_mother), m_firstDaughter(p.m_firstDaughter), m_lastDaughter(p.m_lastDaughter),
      m_secondaryPhysicsProcess(p.m_secondaryPhysicsProcess),
      m_status(p.m_status),
      m_validVertex(p.m_validVertex),
      m_seenIn(p.m_seenIn) {}





    int getPDG() const { return m_pdg; }
# 107 "include/mdst/dataobjects/MCParticle.h"
    unsigned int getStatus(unsigned short int bitmask = (32767 * 2 + 1)) const { return m_status & bitmask; }






    bool hasStatus(unsigned short int bitmask) const { return (m_status & bitmask) == bitmask; }





    float getMass() const { return m_mass; }





    float getCharge() const;





    float getEnergy() const { return m_energy; }





    bool hasValidVertex() const { return m_validVertex; }





    float getProductionTime() const { return m_productionTime; }
# 153 "include/mdst/dataobjects/MCParticle.h"
    float getDecayTime() const { return m_decayTime; }
# 162 "include/mdst/dataobjects/MCParticle.h"
    float getLifetime() const { return m_decayTime - m_productionTime; }





    ROOT::Math::XYZVector getVertex() const { return getProductionVertex(); }





    ROOT::Math::XYZVector getProductionVertex() const
    {
      return ROOT::Math::XYZVector(m_productionVertex_x, m_productionVertex_y, m_productionVertex_z);
    }





    ROOT::Math::XYZVector getMomentum() const
    {
      return ROOT::Math::XYZVector(m_momentum_x, m_momentum_y, m_momentum_z);
    }





    ROOT::Math::PxPyPzEVector get4Vector() const
    {
      return ROOT::Math::PxPyPzEVector(m_momentum_x, m_momentum_y, m_momentum_z, m_energy);
    }
# 204 "include/mdst/dataobjects/MCParticle.h"
    ROOT::Math::XYZVector getDecayVertex() const
    {
      return ROOT::Math::XYZVector(m_decayVertex_x, m_decayVertex_y, m_decayVertex_z);
    }







    int getIndex() const { fixParticleList(); return m_index; }
# 229 "include/mdst/dataobjects/MCParticle.h"
    int getArrayIndex() const { fixParticleList(); return m_index - 1; }






    int getFirstDaughter() const { return m_firstDaughter; }







    int getLastDaughter() const { return m_lastDaughter; }
# 254 "include/mdst/dataobjects/MCParticle.h"
    std::vector<Belle2::MCParticle*> getDaughters() const;



    const MCParticle* getDaughter(int i) const;


    int getNDaughters() const;







    MCParticle* getMother() const;
# 282 "include/mdst/dataobjects/MCParticle.h"
    int getSecondaryPhysicsProcess() const {return m_secondaryPhysicsProcess;}





    Const::DetectorSet getSeenInDetector() const { return m_seenIn; }






    bool hasSeenInDetector(Const::DetectorSet set) const { return m_seenIn.contains(set); }





    bool isVirtual() const;





    bool isInitial() const;






    bool isPrimaryParticle() const;





    void setPDG(int pdg) { m_pdg = pdg; }




    void setMassFromPDG();





    void setStatus(unsigned short int status) { m_status = status; }






    void addStatus(unsigned short int bitmask) { m_status |= bitmask; }






    void removeStatus(unsigned short int bitmask) { m_status &= (~bitmask); }





    void setMass(float mass) { m_mass = mass; }





    void setEnergy(float energy) { m_energy = energy; }





    void setValidVertex(bool valid) { m_validVertex = valid; }





    void setProductionTime(float time) { m_productionTime = time; }





    void setDecayTime(float time) { m_decayTime = time; }





    void setProductionVertex(const ROOT::Math::XYZVector& vertex)
    {
      m_productionVertex_x = vertex.X(); m_productionVertex_y = vertex.Y(), m_productionVertex_z = vertex.Z();
    }
# 393 "include/mdst/dataobjects/MCParticle.h"
    void setProductionVertex(float x, float y, float z)
    {
      m_productionVertex_x = x; m_productionVertex_y = y; m_productionVertex_z = z;
    }





    void setMomentum(const ROOT::Math::XYZVector& momentum)
    {
      m_momentum_x = momentum.X(); m_momentum_y = momentum.Y(), m_momentum_z = momentum.Z();
    }
# 414 "include/mdst/dataobjects/MCParticle.h"
    void setMomentum(float px, float py, float pz)
    {
      m_momentum_x = px, m_momentum_y = py; m_momentum_z = pz;
    }





    void set4Vector(const ROOT::Math::PxPyPzEVector& p4)
    {
      m_momentum_x = p4.px(); m_momentum_y = p4.py(); m_momentum_z = p4.pz(); m_energy = p4.energy();
    }





    void setDecayVertex(const ROOT::Math::XYZVector& vertex)
    {
      m_decayVertex_x = vertex.X(); m_decayVertex_y = vertex.Y(), m_decayVertex_z = vertex.Z();
    }
# 444 "include/mdst/dataobjects/MCParticle.h"
    void setDecayVertex(float x, float y, float z)
    {
      m_decayVertex_x = x; m_decayVertex_y = y; m_decayVertex_z = z;
    }





    void setSecondaryPhysicsProcess(int physicsProcess) { m_secondaryPhysicsProcess = physicsProcess; }





    void setSeenInDetector(Const::DetectorSet set) { m_seenIn = set; }





    void addSeenInDetector(Const::DetectorSet set) { m_seenIn += set; }





    void removeSeenInDetector(Const::DetectorSet set) { m_seenIn -= set; }
# 480 "include/mdst/dataobjects/MCParticle.h"
    void fixParticleList() const;




    void setVirtual() { addStatus(c_IsVirtual); }




    void setInitial() { addStatus(c_Initial); }


    virtual std::string getName() const override;


    virtual std::string getInfoHTML() const override;
# 506 "include/mdst/dataobjects/MCParticle.h"
    const MCParticle* getParticleFromGeneralizedIndexString(const std::string& generalizedIndex) const;

  protected:
# 517 "include/mdst/dataobjects/MCParticle.h"
    TClonesArray* m_plist = nullptr;

    float m_productionTime = 0;
    float m_productionVertex_x = 0;
    float m_productionVertex_y = 0;
    float m_productionVertex_z = 0;

    float m_decayTime = 0;
    float m_decayVertex_x = 0;
    float m_decayVertex_y = 0;
    float m_decayVertex_z = 0;

    int m_pdg = 0;
    float m_mass = 0;
    float m_energy = 0;
    float m_momentum_x = 0;
    float m_momentum_y = 0;
    float m_momentum_z = 0;





    int m_index = 0;

    int m_mother = 0;
    int m_firstDaughter = 0;
    int m_lastDaughter = 0;

    int m_secondaryPhysicsProcess = 0;

    unsigned short int m_status = 0;

    bool m_validVertex = false;
    static const double c_epsilon;

    Const::DetectorSet m_seenIn;

    private: static_assert(std::is_integral<decltype(6)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); Bool_t CheckTObjectHashConsistency() const override { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("MCParticle") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 6; } TClass *IsA() const override { return MCParticle::Class(); } void ShowMembers(TMemberInspector &insp) const override { ::ROOT::Class_ShowMembers(MCParticle::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { MCParticle::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/mdst/dataobjects/MCParticle.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); void Streamer(TBuffer&) override; static int DeclFileLine() { return 555; };

    friend class FixMergedObjectsModule;
  };


  inline bool MCParticle::isVirtual() const
  {
    bool virtuality = hasStatus(c_IsVirtual);
    if (!virtuality) {
      double E2 = m_energy * m_energy;
      double m2 = m_mass * m_mass;
      double p2 = m_momentum_x * m_momentum_x;
      p2 += m_momentum_y * m_momentum_y;
      p2 += m_momentum_z * m_momentum_z;

      virtuality = (fabs(E2 - (p2 + m2)) > c_epsilon * E2);
    }
    return virtuality;
  }

  inline bool MCParticle::isInitial() const
  {
    return hasStatus(c_Initial);
  }

  inline bool MCParticle::isPrimaryParticle() const
  {
    return hasStatus(c_PrimaryParticle);
  }

  inline MCParticle* MCParticle::getMother() const
  {
    if (m_mother == 0)
      return nullptr;
    fixParticleList();
    return static_cast<MCParticle*>(m_plist->At(m_mother - 1));
  }

}
# 14 "include/mdst/dataobjects/MCParticleGraph.h" 2





namespace Belle2 {
# 33 "include/mdst/dataobjects/MCParticleGraph.h"
  class MCParticleGraph {

  public:




    class CyclicReferenceError : public std::runtime_error { public: CyclicReferenceError(): std::runtime_error(""), m_format("Cyclic decay, cannot continue") { } ~CyclicReferenceError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> CyclicReferenceError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;

    class NotSameGraphError : public std::runtime_error { public: NotSameGraphError(): std::runtime_error(""), m_format("Particles not from same graph") { } ~NotSameGraphError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> NotSameGraphError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;

    class NonContinousDaughtersError : public std::runtime_error { public: NonContinousDaughtersError(): std::runtime_error(""), m_format("Can not represent decay graph, non continuous indices for daughters") { } ~NonContinousDaughtersError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> NonContinousDaughtersError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;

    class DaughterHasMotherError : public std::runtime_error { public: DaughterHasMotherError(): std::runtime_error(""), m_format("A daughter particle was already assigned to a mother. A particle can't have two mothers!") { } ~DaughterHasMotherError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> DaughterHasMotherError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;


    class OutOfRangeError : public std::runtime_error { public: OutOfRangeError(): std::runtime_error(""), m_format("Index out of range") { } ~OutOfRangeError() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> OutOfRangeError& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;


    typedef std::pair<unsigned int, unsigned int> DecayLine;


    enum GraphOptions {
      c_setNothing = 0,
      c_setDecayVertex = 1,
      c_setDecayTime = 2,
      c_setDecayInfo = c_setDecayVertex | c_setDecayTime,
      c_checkCyclic = 4,
      c_clearParticles = 8
    };
# 71 "include/mdst/dataobjects/MCParticleGraph.h"
    class GraphParticle: public MCParticle {

    public:







      GraphParticle& operator=(const MCParticle& particle)
      {
        MCParticle::operator=(particle);



        m_plist = (TClonesArray*) - 1;
        return *this;
      }





      void decaysInto(GraphParticle& daughter) { m_graph->addDecay(*this, daughter); }





      void comesFrom(GraphParticle& mother) { m_graph->addDecay(mother, *this); }
# 110 "include/mdst/dataobjects/MCParticleGraph.h"
      void setFirstDaughter(int daughter) { m_firstDaughter = daughter; }







      void setLastDaughter(int daughter) { m_lastDaughter = daughter; }
# 128 "include/mdst/dataobjects/MCParticleGraph.h"
      void setIgnore(bool ignore = true) { m_ignore = ignore; }






      bool getIgnore() const { return m_ignore; }







      void setTrackID(int trackID) { m_trackID = trackID; }






      int getTrackID() const { return m_trackID; }


    private:




      GraphParticle() = delete;




      GraphParticle(const GraphParticle&) = delete;




      GraphParticle(TClonesArray*, const MCParticle&) {}







      GraphParticle(MCParticleGraph* graph, unsigned int vertexId): MCParticle(),
        m_graph(graph), m_vertexId(vertexId)
      {



        m_plist = (TClonesArray*) - 1;
      }





      void setIndex(int index) { m_index = index; }

      MCParticleGraph* m_graph{0};
      unsigned int m_vertexId{0};
      int m_trackID{0};
      bool m_ignore{false};
      bool m_primary{true};

      friend class MCParticleGraph;
      friend class ParticleSorter;
    };




    MCParticleGraph() {}





    virtual ~MCParticleGraph() { clear(); }






    GraphParticle& addParticle();
# 226 "include/mdst/dataobjects/MCParticleGraph.h"
    void addDecay(GraphParticle& mother, GraphParticle& daughter);





    GraphParticle& operator[](size_t i) { if (i >= m_particles.size()) throw OutOfRangeError(); return *m_particles[i]; }





    size_t size() const { return m_particles.size(); }
# 252 "include/mdst/dataobjects/MCParticleGraph.h"
    void generateList(const std::string& name = "", int options = c_setNothing);







    void loadList(const std::string& name = "");






    void clear();


  protected:





    class ParticleSorter;

    MemoryPool<GraphParticle> m_particles;
    std::set<DecayLine> m_decays;
  };


  inline void MCParticleGraph::clear()
  {
    m_particles.clear();
    m_decays.clear();
  }


  inline MCParticleGraph::GraphParticle& MCParticleGraph::addParticle()
  {
    unsigned int index = m_particles.size() + 1;
    MCParticleGraph::GraphParticle* p = new (m_particles.add()) MCParticleGraph::GraphParticle(this, index);
    return *p;
  }


  inline void MCParticleGraph::addDecay(MCParticleGraph::GraphParticle& mother, MCParticleGraph::GraphParticle& daughter)
  {
    if (this != mother.m_graph || this != daughter.m_graph) throw NotSameGraphError();

    m_decays.insert(DecayLine(mother.m_vertexId, daughter.m_vertexId));
    daughter.m_primary = false;
  }

}
# 13 "include/simulation/kernel/UserInfo.h" 2
# 1 "include/simulation/dataobjects/MCParticleTrajectory.h" 1
# 12 "include/simulation/dataobjects/MCParticleTrajectory.h"
# 1 "include/simulation/dataobjects/MCTrajectoryPoint.h" 1
# 11 "include/simulation/dataobjects/MCTrajectoryPoint.h"
namespace Belle2 {

  struct MCTrajectoryPoint {

    MCTrajectoryPoint(float x_ = 0, float y_ = 0, float z_ = 0, float px_ = 0, float py_ = 0, float pz_ = 0):
      x(x_), y(y_), z(z_), px(px_), py(py_), pz(pz_) {}
    float x;
    float y;
    float z;
    float px;
    float py;
    float pz;
  };
}
# 13 "include/simulation/dataobjects/MCParticleTrajectory.h" 2


namespace Belle2 {

  class MCParticleTrajectory: public RelationsObject {
  public:

    MCParticleTrajectory(): RelationsObject(), m_points() {}


    typedef std::vector<MCTrajectoryPoint>::iterator iterator;

    typedef std::vector<MCTrajectoryPoint>::const_iterator const_iterator;

    iterator begin() { return m_points.begin(); }

    iterator end() { return m_points.end(); }

    const_iterator begin() const { return m_points.begin(); }

    const_iterator end() const { return m_points.end(); }

    size_t size() const { return m_points.size(); }

    bool empty() const { return m_points.empty(); }

    const MCTrajectoryPoint& operator[](size_t index) const { return m_points[index]; }

    const MCTrajectoryPoint& front() const { return m_points.front(); }

    const MCTrajectoryPoint& back() const { return m_points.back(); }
# 52 "include/simulation/dataobjects/MCParticleTrajectory.h"
    void addPoint(float x, float y, float z, float px, float py, float pz)
    {

      m_points.emplace_back(x, y, z, px, py, pz);
    }





    void simplify(float distanceTolerance);

  private:

    std::vector<MCTrajectoryPoint> m_points;


    private: static_assert(std::is_integral<decltype(1)>::value, "ClassDef(Inline) macro: the specified class version number is not an integer."); virtual Bool_t CheckTObjectHashConsistency() const { static std::atomic<UChar_t> recurseBlocker(0); if (__builtin_expect(!!(recurseBlocker >= 2), 1)) { return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } else if (recurseBlocker == 1) { return false; } else if (recurseBlocker++ == 0) { ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = ::ROOT::Internal::HasConsistentHashMember("MCParticleTrajectory") || ::ROOT::Internal::HasConsistentHashMember(*IsA()); ++recurseBlocker; return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; } return false; } public: static constexpr Version_t Class_Version() { return 1; } virtual TClass *IsA() const { return MCParticleTrajectory::Class(); } virtual void ShowMembers(TMemberInspector &insp) const { ::ROOT::Class_ShowMembers(MCParticleTrajectory::Class(), this, insp); } void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { MCParticleTrajectory::Streamer(ClassDef_StreamerNVirtual_b); } static const char *DeclFileName() { return "include/simulation/dataobjects/MCParticleTrajectory.h"; } private: static atomic_TClass_ptr fgIsA; public: static int ImplFileLine(); static const char *ImplFileName(); static const char *Class_Name(); static TClass *Dictionary(); static TClass *Class(); virtual void Streamer(TBuffer&) ; static int DeclFileLine() { return 69; };
  };

}
# 14 "include/simulation/kernel/UserInfo.h" 2

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VUserTrackInformation.hh" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VUserTrackInformation.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ios.hh" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ios.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4GlobalConfig.hh" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 2 3
# 74 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc99-extensions"





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<typename _Tp> class complex;
  template<> class complex<float>;
  template<> class complex<double>;
  template<> class complex<long double>;


  template<typename _Tp> _Tp abs(const complex<_Tp>&);

  template<typename _Tp> _Tp arg(const complex<_Tp>&);

  template<typename _Tp> _Tp constexpr norm(const complex<_Tp>&);


  template<typename _Tp>
    constexpr complex<_Tp> conj(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);



  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
                                          const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
# 155 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<typename _Tp>
    class complex
    {
    public:

      typedef _Tp value_type;



      constexpr complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
      : _M_real(__r), _M_imag(__i) { }



      constexpr complex(const complex&) = default;



      template<typename _Up>



 constexpr complex(const complex<_Up>& __z)
 : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      real() const { return _M_real; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      imag() const { return _M_imag; }
# 210 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr void
      real(_Tp __val) { _M_real = __val; }

      constexpr void
      imag(_Tp __val) { _M_imag = __val; }


      constexpr complex<_Tp>& operator=(const _Tp&);



      constexpr complex<_Tp>&
      operator+=(const _Tp& __t)
      {
 _M_real += __t;
 return *this;
      }



      constexpr complex<_Tp>&
      operator-=(const _Tp& __t)
      {
 _M_real -= __t;
 return *this;
      }


      constexpr complex<_Tp>& operator*=(const _Tp&);

      constexpr complex<_Tp>& operator/=(const _Tp&);



      constexpr complex& operator=(const complex&) = default;



      template<typename _Up>
        constexpr complex<_Tp>& operator=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator+=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator-=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator*=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator/=(const complex<_Up>&);

      constexpr complex __rep() const
      { return *this; }
# 276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
    private:
      _Tp _M_real;
      _Tp _M_imag;
    };

  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator*=(const _Tp& __t)
    {
      _M_real *= __t;
      _M_imag *= __t;
      return *this;
    }


  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator/=(const _Tp& __t)
    {
      _M_real /= __t;
      _M_imag /= __t;
      return *this;
    }

  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator=(const complex<_Up>& __z)
    {
      _M_real = __z.real();
      _M_imag = __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator+=(const complex<_Up>& __z)
    {
      _M_real += __z.real();
      _M_imag += __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator-=(const complex<_Up>& __z)
    {
      _M_real -= __z.real();
      _M_imag -= __z.imag();
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator*=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
      _M_real = __r;
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator/=(const complex<_Up>& __z)
    {
      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
      const _Tp __n = std::norm(__z);
      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
      _M_real = __r / __n;
      return *this;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = -__y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r *= __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }



  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x)
    { return __x; }


  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x)
    { return complex<_Tp>(-__x.real(), -__x.imag()); }



  template<typename _Tp>
    inline constexpr bool
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }

  template<typename _Tp>
    inline constexpr bool
    operator==(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() == __y && __x.imag() == _Tp(); }
# 541 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<typename _Tp, typename _CharT, class _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
    {
      bool __fail = true;
      _CharT __ch;
      if (__is >> __ch)
 {
   if (_Traits::eq(__ch, __is.widen('(')))
     {
       _Tp __u;
       if (__is >> __u >> __ch)
  {
    const _CharT __rparen = __is.widen(')');
    if (_Traits::eq(__ch, __rparen))
      {
        __x = __u;
        __fail = false;
      }
    else if (_Traits::eq(__ch, __is.widen(',')))
      {
        _Tp __v;
        if (__is >> __v >> __ch)
   {
     if (_Traits::eq(__ch, __rparen))
       {
         __x = complex<_Tp>(__u, __v);
         __fail = false;
       }
     else
       __is.putback(__ch);
   }
      }
    else
      __is.putback(__ch);
  }
     }
   else
     {
       __is.putback(__ch);
       _Tp __u;
       if (__is >> __u)
  {
    __x = __u;
    __fail = false;
  }
     }
 }
      if (__fail)
 __is.setstate(ios_base::failbit);
      return __is;
    }


  template<typename _Tp, typename _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
    {
      basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
      return __os << __s.str();
    }



  template<typename _Tp>
    constexpr _Tp
    real(const complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    constexpr _Tp
    imag(const complex<_Tp>& __z)
    { return __z.imag(); }
# 937 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 973 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1003 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<bool>
    struct _Norm_helper
    {
      template<typename _Tp>
        static inline constexpr _Tp _S_do_it(const complex<_Tp>& __z)
        {
          const _Tp __x = __z.real();
          const _Tp __y = __z.imag();
          return __x * __x + __y * __y;
        }
    };

  template<>
    struct _Norm_helper<true>
    {
      template<typename _Tp>
        static inline constexpr _Tp _S_do_it(const complex<_Tp>& __z)
        {


          const _Tp __x = __z.real();
          const _Tp __y = __z.imag();
          return __x * __x + __y * __y;
        }
    };

  template<typename _Tp>
    inline constexpr _Tp
    norm(const complex<_Tp>& __z)
    {
      return _Norm_helper<__is_floating<_Tp>::__value
 && !0>::_S_do_it(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    polar(const _Tp& __rho, const _Tp& __theta)
    {
      do { if (std::__is_constant_evaluated() && !bool(__rho >= 0)) std::__glibcxx_assert_fail(); } while (false);
      return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    conj(const complex<_Tp>& __z)
    { return complex<_Tp>(__z.real(), -__z.imag()); }




  template<typename _Tp>
    inline complex<_Tp>
    __complex_cos(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
    }


  inline __complex__ float
  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }

  inline __complex__ double
  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }

  inline __complex__ long double
  __complex_cos(const __complex__ long double& __z)
  { return __builtin_ccosl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_cosh(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
    }


  inline __complex__ float
  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }

  inline __complex__ double
  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }

  inline __complex__ long double
  __complex_cosh(const __complex__ long double& __z)
  { return __builtin_ccoshl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }







  template<typename _Tp>
    inline complex<_Tp>
    __complex_exp(const complex<_Tp>& __z)
    { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }


  inline __complex__ float
  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }

  inline __complex__ double
  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }

  inline __complex__ long double
  __complex_exp(const __complex__ long double& __z)
  { return __builtin_cexpl(__z); }

  template<typename _Tp>
    inline complex<_Tp>
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
# 1140 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1232 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1304 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 1333 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);
    }
# 1434 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<>
    class complex<float>
    {
    public:
      typedef float value_type;
      typedef __complex__ float _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(float __r = 0.0f, float __i = 0.0f)

      : _M_value{ __r, __i } { }
# 1454 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr complex(const complex&) = default;
# 1463 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      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; }
# 1493 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr void
      real(float __val) { __real__ _M_value = __val; }

      constexpr void
      imag(float __val) { __imag__ _M_value = __val; }

      constexpr complex&
      operator=(float __f)
      {
 _M_value = __f;
 return *this;
      }

      constexpr complex&
      operator+=(float __f)
      {
 _M_value += __f;
 return *this;
      }

      constexpr complex&
      operator-=(float __f)
      {
 _M_value -= __f;
 return *this;
      }

      constexpr complex&
      operator*=(float __f)
      {
 _M_value *= __f;
 return *this;
      }

      constexpr complex&
      operator/=(float __f)
      {
 _M_value /= __f;
 return *this;
      }




      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<class _Tp>
        constexpr complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<class _Tp>
        constexpr complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<class _Tp>
        constexpr complex&
        operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }



    private:
      _ComplexT _M_value;
    };



  template<>
    class complex<double>
    {
    public:
      typedef double value_type;
      typedef __complex__ double _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(double __r = 0.0, double __i = 0.0)

      : _M_value{ __r, __i } { }
# 1613 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr complex(const complex&) = default;
# 1622 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      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; }
# 1654 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr void
      real(double __val) { __real__ _M_value = __val; }

      constexpr void
      imag(double __val) { __imag__ _M_value = __val; }

      constexpr complex&
      operator=(double __d)
      {
 _M_value = __d;
 return *this;
      }

      constexpr complex&
      operator+=(double __d)
      {
 _M_value += __d;
 return *this;
      }

      constexpr complex&
      operator-=(double __d)
      {
 _M_value -= __d;
 return *this;
      }

      constexpr complex&
      operator*=(double __d)
      {
 _M_value *= __d;
 return *this;
      }

      constexpr complex&
      operator/=(double __d)
      {
 _M_value /= __d;
 return *this;
      }



      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }



    private:
      _ComplexT _M_value;
    };



  template<>
    class complex<long double>
    {
    public:
      typedef long double value_type;
      typedef __complex__ long double _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(long double __r = 0.0L,
     long double __i = 0.0L)

      : _M_value{ __r, __i } { }
# 1773 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr complex(const complex&) = default;
# 1782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      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; }
# 1815 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
      constexpr void
      real(long double __val) { __real__ _M_value = __val; }

      constexpr void
      imag(long double __val) { __imag__ _M_value = __val; }

      constexpr complex&
      operator=(long double __r)
      {
 _M_value = __r;
 return *this;
      }

      constexpr complex&
      operator+=(long double __r)
      {
 _M_value += __r;
 return *this;
      }

      constexpr complex&
      operator-=(long double __r)
      {
 _M_value -= __r;
 return *this;
      }

      constexpr complex&
      operator*=(long double __r)
      {
 _M_value *= __r;
 return *this;
      }

      constexpr complex&
      operator/=(long double __r)
      {
 _M_value /= __r;
 return *this;
      }



      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }



    private:
      _ComplexT _M_value;
    };
# 2073 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  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 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 = (_Tp) 1.5707963267948966192313216916397514L;
      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
    }
# 2295 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  inline __complex__ float
  __complex_acos(__complex__ float __z)
  { return __builtin_cacosf(__z); }

  inline __complex__ double
  __complex_acos(__complex__ double __z)
  { return __builtin_cacos(__z); }

  inline __complex__ long double
  __complex_acos(const __complex__ long double& __z)
  { return __builtin_cacosl(__z); }

  template<typename _Tp>
    inline std::complex<_Tp>
    acos(const std::complex<_Tp>& __z)
    { return __complex_acos(__z.__rep()); }
# 2321 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 2357 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 2401 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 2437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 2476 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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()); }
# 2520 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<typename _Tp>
    inline _Tp



    fabs(const std::complex<_Tp>& __z)
    { return std::abs(__z); }


  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    arg(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
                        : __type();



    }

  template<typename _Tp>
    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
    imag(_Tp)
    { return _Tp(); }

  template<typename _Tp>
    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
    norm(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __type(__x) * __type(__x);
    }

  template<typename _Tp>
    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
    real(_Tp __x)
    { return __x; }

  template<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
    pow(const std::complex<_Tp>& __x, const _Up& __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return std::pow(std::complex<__type>(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
    pow(const _Tp& __x, const std::complex<_Up>& __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return std::pow(__type(__x), std::complex<__type>(__y));
    }

  template<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return std::pow(std::complex<__type>(__x),
        std::complex<__type>(__y));
    }



  template<typename _Tp>
    std::complex<_Tp> proj(const std::complex<_Tp>&);


  template<typename _Tp>
    inline std::complex<_Tp>
    __complex_proj(const std::complex<_Tp>& __z)
    { return __z; }


  inline complex<float>
  __complex_proj(const complex<float>& __z)
  { return __builtin_cprojf(__z.__rep()); }

  inline complex<double>
  __complex_proj(const complex<double>& __z)
  { return __builtin_cproj(__z.__rep()); }

  inline complex<long double>
  __complex_proj(const complex<long double>& __z)
  { return __builtin_cprojl(__z.__rep()); }
# 2680 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/complex" 3
  template<typename _Tp>
    inline std::complex<_Tp>
    proj(const std::complex<_Tp>& __z)
    { return __complex_proj(__z); }


  template<typename _Tp>
    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
    proj(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return std::proj(std::complex<__type>(__x));
    }

  template<typename _Tp>
    inline constexpr
 std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
    conj(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return std::complex<__type>(__x, -__type());
    }



inline namespace literals {
inline namespace complex_literals {
#pragma GCC diagnostic push


  constexpr std::complex<float>
  operator""if(long double __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }

  constexpr std::complex<float>
  operator""if(unsigned long long __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }

  constexpr std::complex<double>
  operator""i(long double __num)
  { return std::complex<double>{0.0, static_cast<double>(__num)}; }

  constexpr std::complex<double>
  operator""i(unsigned long long __num)
  { return std::complex<double>{0.0, static_cast<double>(__num)}; }

  constexpr std::complex<long double>
  operator""il(long double __num)
  { return std::complex<long double>{0.0L, __num}; }

  constexpr std::complex<long double>
  operator""il(unsigned long long __num)
  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }

#pragma GCC diagnostic pop
}
}




}




#pragma clang diagnostic pop


#pragma GCC diagnostic pop
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/tls.hh" 1 3
# 79 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Types.hh" 2 3




using G4double = double;
using G4float = float;
using G4int = int;
using G4bool = bool;
using G4long = long;
using G4complex = std::complex<G4double>;




class __void__;
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ios.hh" 2 3



class G4coutDestination;
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ios.hh" 3
extern std::ostream G4debug;
extern std::ostream G4cout;
extern std::ostream G4cerr;



void G4iosInitialization();
void G4iosFinalization();




void G4iosSetDestination(G4coutDestination* sink);
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 2 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 3
class G4String : public std::string
{
 public:


  enum caseCompare
  {
    exact,
    ignoreCase
  };



  enum stripType
  {
    leading,
    trailing,
    both
  };

  using std::string::string;
  using std::string::operator=;

  inline G4String() = default;
  inline G4String(const std::string&);
  inline G4String(const G4String&);
  inline G4String(std::string&&);
  inline G4String(G4String&&);
  inline G4String& operator=(const G4String&);
  inline G4String& operator=(G4String&&);






  inline operator const char*() const;
# 109 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 3
  inline reference operator[](int);


  inline const_reference operator[](int) const;



  [[deprecated("Use std::string::compare, or G4StrUtil::icompare for case-insensitive comparison")]]
  inline G4int compareTo(std::string_view, caseCompare mode = exact) const;



  [[deprecated("Use std::getline instead, plus G4StrUtil::lstrip if required")]]
  inline std::istream& readLine(std::istream&, G4bool skipWhite = true);



  [[deprecated("Use std::string::erase instead")]]
  inline G4String& remove(size_type);



  [[deprecated("Use G4StrUtil::contains instead")]]
  inline G4bool contains(const std::string&) const;



  [[deprecated("Use G4StrUtil::contains instead")]]
  inline G4bool contains(char) const;



  [[deprecated("Use G4StrUtil::{lstrip,rstrip,strip}_copy instead")]]
  [[nodiscard]] inline G4String strip(stripType strip_Type = trailing, char ch = ' ');



  [[deprecated("Use G4StrUtil::to_lower/to_lower_copy instead")]]
  inline void toLower();



  [[deprecated("Use G4StrUtil::to_upper/to_upper_copy instead")]]
  inline void toUpper();
};







namespace G4StrUtil
{


  inline void to_lower(G4String& str);




  inline G4String to_lower_copy(G4String str);



  inline void to_upper(G4String& str);




  inline G4String to_upper_copy(G4String str);





  void lstrip(G4String& str, char ch = ' ');





  void rstrip(G4String& str, char ch = ' ');





  void strip(G4String& str, char ch = ' ');





  G4String lstrip_copy(G4String str, char ch = ' ');





  G4String rstrip_copy(G4String str, char ch = ' ');





  G4String strip_copy(G4String str, char ch = ' ');






  inline G4bool contains(const G4String& str, std::string_view ss);


  inline G4bool contains(const G4String& str, char ss);


  inline G4bool contains(const G4String& str, const char* ss);







  inline G4bool contains(const G4String& str, const G4String& ss);
# 248 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 3
  inline G4int icompare(std::string_view lhs, std::string_view rhs);






  inline bool starts_with(const G4String& str, std::string_view ss);


  inline bool starts_with(const G4String& str, G4String::value_type ss);


  inline bool starts_with(const G4String& str, const char* ss);







  inline bool starts_with(const G4String& str, const G4String& ss);






  inline bool ends_with(const G4String& str, std::string_view ss);


  inline bool ends_with(const G4String& str, G4String::value_type ss);


  inline bool ends_with(const G4String& str, const char* ss);


  inline bool ends_with(const G4String& str, const G4String& ss);
# 301 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 3
  inline void safe_erase(G4String& str, G4String::size_type index = 0,
                         G4String::size_type count = G4String::npos);
# 313 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 3
  inline std::istream& readline(std::istream& is, G4String& str, G4bool skipWhite = true);
}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.icc" 3
inline G4String::G4String(const std::string& str)
  : std::string(str)
{}

inline G4String::G4String(const G4String& str) = default;

inline G4String::G4String(std::string&& str)
  : std::string(std::move(str))
{}

inline G4String::G4String(G4String&& str)
  : std::string(std::move(str))
{}

inline G4String& G4String::operator=(const G4String& str)
{
  if(&str == this)
  {
    return *this;
  }
  std::string::operator=(str);
  return *this;
}

inline G4String& G4String::operator=(G4String&& str)
{
  std::string::operator=(std::move(str));
  return *this;
}

inline G4String::operator const char*() const { return c_str(); }

inline G4String::reference G4String::operator[](int pos)
{
  return std::string::operator[](pos);
}

inline G4String::const_reference G4String::operator[](int pos) const
{
    return std::string::operator[](pos);
}

inline G4int G4String::compareTo(std::string_view str, caseCompare mode) const
{
  if(mode == exact)
  {
    return compare(str);
  }

  return G4StrUtil::icompare(*this, str);
}

inline std::istream& G4String::readLine(std::istream& strm, G4bool skipWhite)
{
  return G4StrUtil::readline(strm, *this, skipWhite);
}

inline G4String& G4String::remove(size_type n)
{
  G4StrUtil::safe_erase(*this, n);
  return *this;
}

inline G4bool G4String::contains(const std::string& str) const
{

  return G4StrUtil::contains(*this, str.c_str());
}

inline G4bool G4String::contains(char ch) const
{
  return G4StrUtil::contains(*this, ch);
}

inline G4String G4String::strip(G4String::stripType strip_Type, char ch)
{
  if(empty())
  {
    return "";
  }

  G4String retVal = *this;

  switch(strip_Type)
  {
    case G4String::leading:
      G4StrUtil::lstrip(retVal, ch);
      break;
    case G4String::trailing:
      G4StrUtil::rstrip(retVal, ch);
      break;
    case G4String::both:
      G4StrUtil::strip(retVal, ch);
      break;
    default:
      break;
  }

  return retVal;
}

inline void G4String::toLower() { G4StrUtil::to_lower(*this); }

inline void G4String::toUpper() { G4StrUtil::to_upper(*this); }

namespace G4StrUtil
{
  inline void to_lower(G4String& str)
  {
    std::transform(str.begin(), str.end(), str.begin(),
                   [](unsigned char ch) { return std::tolower(ch); });
  }

  inline G4String to_lower_copy(G4String str)
  {
    to_lower(str);
    return str;
  }

  inline void to_upper(G4String& str)
  {
    std::transform(str.begin(), str.end(), str.begin(),
                   [](unsigned char ch) { return std::toupper(ch); });
  }

  inline G4String to_upper_copy(G4String str)
  {
    to_upper(str);
    return str;
  }

  inline void lstrip(G4String& str, char ch)
  {
    auto startIndex = str.find_first_not_of(ch);
    str.erase(0, startIndex);
  }

  inline void rstrip(G4String& str, char ch)
  {
    auto endIndex = str.find_last_not_of(ch);
    if(endIndex == G4String::npos)
    {
      str = "";
    }
    else
    {
      str.erase(endIndex + 1);
    }
  }

  inline void strip(G4String& str, char ch)
  {
    if(str.empty())
    {
      return;
    }

    lstrip(str, ch);
    rstrip(str, ch);
  }

  inline G4String lstrip_copy(G4String str, char ch)
  {
    lstrip(str, ch);
    return str;
  }

  inline G4String rstrip_copy(G4String str, char ch)
  {
    rstrip(str, ch);
    return str;
  }

  inline G4String strip_copy(G4String str, char ch)
  {
    strip(str, ch);
    return str;
  }

  inline G4bool contains(const G4String& str, std::string_view ss)
  {
    return str.find(ss) != G4String::npos;
  }

  inline G4bool contains(const G4String& str, char ss)
  {
    return str.find(ss) != G4String::npos;
  }

  inline G4bool contains(const G4String& str, const char* ss)
  {
    return str.find(ss) != G4String::npos;
  }

  inline G4bool contains(const G4String& str, const G4String& ss)
  {
    return str.find(ss) != G4String::npos;
  }

  inline G4int icompare(std::string_view lhs, std::string_view rhs)
  {
    G4String buf1 = G4StrUtil::to_lower_copy(G4String(lhs.data(), lhs.size()));
    G4String buf2 = G4StrUtil::to_lower_copy(G4String(rhs.data(), rhs.size()));
    return buf1.compare(buf2);
  }

  inline bool starts_with(const G4String& str, std::string_view ss)
  {
    return str.rfind(ss, 0) == 0;
  }

  inline bool starts_with(const G4String& str, G4String::value_type ss)
  {
    return !str.empty() && (str[0] == ss);
  }

  inline bool starts_with(const G4String& str, const char* ss)
  {
    return str.rfind(ss, 0) == 0;
  }

  inline bool starts_with(const G4String& str, const G4String& ss)
  {
    return str.rfind(ss, 0) == 0;
  }

  inline bool ends_with(const G4String& str, std::string_view ss)
  {
    if(str.length() < ss.length())
    {
      return false;
    }
    return str.compare(str.length() - ss.length(), ss.length(), ss) == 0;
  }

  inline bool ends_with(const G4String& str, G4String::value_type ss)
  {
    return !str.empty() && (str.back() == ss);
  }

  inline bool ends_with(const G4String& str, const char* ss)
  {
    std::string_view sv(ss);
    return ends_with(str, sv);
  }

  inline bool ends_with(const G4String& str, const G4String& ss)
  {
    return ends_with(str, ss.c_str());
  }

  inline void safe_erase(G4String& str, G4String::size_type index,
                         G4String::size_type count)
  {
    if(index < str.size())
    {
      str.erase(index, count);
    }
  }

  inline std::istream& readline(std::istream& is, G4String& str,
                                G4bool skipWhite)
  {
    char tmp[1024];
    if(skipWhite)
    {
      is >> std::ws;
    }

    is.getline(tmp, 1024);
    str = tmp;

    return is;
  }
}
# 317 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4String.hh" 2 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/templates.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/templates.hh" 3
using Float = double;
# 103 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/templates.hh" 3
template <class T>
inline void G4SwapPtr(T*& a, T*& b)
{
  T* tmp = a;
  a = b;
  b = tmp;
}

template <class T>
inline void G4SwapObj(T* a, T* b)
{
  T tmp = *a;
  *a = *b;
  *b = tmp;
}
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/templates.hh" 3
template <class T>
inline T sqr(const T& x)
{
  return x * x;
}


inline int G4lrint(double ad)
{
  return (int)std::lrint(ad);
}
# 176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/templates.hh" 3
template <typename... _Args>
inline void G4ConsumeParameters(_Args&&...)
{}
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Exception.hh" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Exception.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ExceptionSeverity.hh" 1 3
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ExceptionSeverity.hh" 3
enum G4ExceptionSeverity
{
  FatalException,
  FatalErrorInArgument,
  RunMustBeAborted,
  EventMustBeAborted,
  JustWarning,
  IgnoreTheIssue
};
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Exception.hh" 2 3



using G4ExceptionDescription = std::ostringstream;

void G4Exception(const char* originOfException,
                 const char* exceptionCode, G4ExceptionSeverity severity,
                 const char* description);

void G4Exception(const char* originOfException,
                 const char* exceptionCode, G4ExceptionSeverity severity,
                 G4ExceptionDescription& description);

void G4Exception(const char* originOfException,
                 const char* exceptionCode, G4ExceptionSeverity severity,
                 G4ExceptionDescription& description,
                 const char* comments);
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4EnvironmentUtils.hh" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4EnvironmentUtils.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<intmax_t _Pn>
    struct __static_sign
    : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>
    { };

  template<intmax_t _Pn>
    struct __static_abs
    : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>
    { };

  template<intmax_t _Pn, intmax_t _Qn>
    struct __static_gcd
    : __static_gcd<_Qn, (_Pn % _Qn)>
    { };

  template<intmax_t _Pn>
    struct __static_gcd<_Pn, 0>
    : integral_constant<intmax_t, __static_abs<_Pn>::value>
    { };

  template<intmax_t _Qn>
    struct __static_gcd<0, _Qn>
    : integral_constant<intmax_t, __static_abs<_Qn>::value>
    { };







  template<intmax_t _Pn, intmax_t _Qn>
    struct __safe_multiply
    {
    private:
      static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);

      static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;
      static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;
      static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
      static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;

      static_assert(__a1 == 0 || __b1 == 0,
      "overflow in multiplication");
      static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
      "overflow in multiplication");
      static_assert(__b0 * __a0 <= 9223372036854775807L,
      "overflow in multiplication");
      static_assert((__a0 * __b1 + __b0 * __a1) * __c
      <= 9223372036854775807L - __b0 * __a0,
      "overflow in multiplication");

    public:
      static const intmax_t value = _Pn * _Qn;
    };



  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    struct __big_less
    : integral_constant<bool, (__hi1 < __hi2
          || (__hi1 == __hi2 && __lo1 < __lo2))>
    { };

  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    struct __big_add
    {
      static constexpr uintmax_t __lo = __lo1 + __lo2;
      static constexpr uintmax_t __hi = (__hi1 + __hi2 +
      (__lo1 + __lo2 < __lo1));
    };


  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    struct __big_sub
    {
      static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,
      "Internal library error");
      static constexpr uintmax_t __lo = __lo1 - __lo2;
      static constexpr uintmax_t __hi = (__hi1 - __hi2 -
      (__lo1 < __lo2));
    };


  template<uintmax_t __x, uintmax_t __y>
    struct __big_mul
    {
    private:
      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
      static constexpr uintmax_t __x0 = __x % __c;
      static constexpr uintmax_t __x1 = __x / __c;
      static constexpr uintmax_t __y0 = __y % __c;
      static constexpr uintmax_t __y1 = __y / __c;
      static constexpr uintmax_t __x0y0 = __x0 * __y0;
      static constexpr uintmax_t __x0y1 = __x0 * __y1;
      static constexpr uintmax_t __x1y0 = __x1 * __y0;
      static constexpr uintmax_t __x1y1 = __x1 * __y1;
      static constexpr uintmax_t __mix = __x0y1 + __x1y0;
      static constexpr uintmax_t __mix_lo = __mix * __c;
      static constexpr uintmax_t __mix_hi
      = __mix / __c + ((__mix < __x0y1) ? __c : 0);
      typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;
    public:
      static constexpr uintmax_t __hi = _Res::__hi;
      static constexpr uintmax_t __lo = _Res::__lo;
    };



  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
    struct __big_div_impl
    {
    private:
      static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),
      "Internal library error");
      static_assert(__n1 < __d, "Internal library error");
      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
      static constexpr uintmax_t __d1 = __d / __c;
      static constexpr uintmax_t __d0 = __d % __c;

      static constexpr uintmax_t __q1x = __n1 / __d1;
      static constexpr uintmax_t __r1x = __n1 % __d1;
      static constexpr uintmax_t __m = __q1x * __d0;
      static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
      static constexpr uintmax_t __r1z = __r1y + __d;
      static constexpr uintmax_t __r1
      = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m))
  ? (__r1z + __d) : __r1z : __r1y) - __m;
      static constexpr uintmax_t __q1
      = __q1x - ((__r1y < __m)
   ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
      static constexpr uintmax_t __q0x = __r1 / __d1;
      static constexpr uintmax_t __r0x = __r1 % __d1;
      static constexpr uintmax_t __n = __q0x * __d0;
      static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
      static constexpr uintmax_t __r0z = __r0y + __d;
      static constexpr uintmax_t __r0
      = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n))
  ? (__r0z + __d) : __r0z : __r0y) - __n;
      static constexpr uintmax_t __q0
      = __q0x - ((__r0y < __n) ? ((__r0z >= __d)
      && (__r0z < __n)) ? 2 : 1 : 0);

    public:
      static constexpr uintmax_t __quot = __q1 * __c + __q0;
      static constexpr uintmax_t __rem = __r0;

    private:
      typedef __big_mul<__quot, __d> _Prod;
      typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;
      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
      "Internal library error");
  };

  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
    struct __big_div
    {
    private:
      static_assert(__d != 0, "Internal library error");
      static_assert(sizeof (uintmax_t) == sizeof (unsigned long long),
      "This library calls __builtin_clzll on uintmax_t, which "
      "is unsafe on your platform. Please complain to "
      "http://gcc.gnu.org/bugzilla/");
      static constexpr int __shift = __builtin_clzll(__d);
      static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
      static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
      static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
      static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
      static constexpr uintmax_t __new_d = __d * __c1;
      static constexpr uintmax_t __new_n0 = __n0 * __c1;
      static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
      static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
      static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
      typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;

    public:
      static constexpr uintmax_t __quot_hi = __n1 / __d;
      static constexpr uintmax_t __quot_lo = _Res::__quot;
      static constexpr uintmax_t __rem = _Res::__rem / __c1;

    private:
      typedef __big_mul<__quot_lo, __d> _P0;
      typedef __big_mul<__quot_hi, __d> _P1;
      typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;

      static_assert(_P1::__hi == 0, "Internal library error");
      static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");

      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
      "Internal library error");
      static_assert(__rem < __d, "Internal library error");
    };
# 270 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<intmax_t _Num, intmax_t _Den = 1>
    struct ratio
    {
      static_assert(_Den != 0, "denominator cannot be zero");
      static_assert(_Num >= -9223372036854775807L && _Den >= -9223372036854775807L,
      "out of range");


      static constexpr intmax_t num =
        _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;

      static constexpr intmax_t den =
        __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;

      typedef ratio<num, den> type;
    };
# 297 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<typename _Tp>
    struct __is_ratio
    : std::false_type
    { };

  template<intmax_t _Num, intmax_t _Den>
    struct __is_ratio<ratio<_Num, _Den>>
    : std::true_type
    { };


  template<typename _Tp>
    constexpr bool __is_ratio_v = false;
  template<intmax_t _Num, intmax_t _Den>
    constexpr bool __is_ratio_v<ratio<_Num, _Den>> = true;


  template<typename _R1, typename _R2>
    constexpr bool
    __are_both_ratios() noexcept
    {

      if constexpr (__is_ratio_v<_R1>)
 if constexpr (__is_ratio_v<_R2>)
   return true;
      return false;



    }

  template<typename _R1, typename _R2>
    struct __ratio_multiply
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");

    private:
      static const intmax_t __gcd1 =
        __static_gcd<_R1::num, _R2::den>::value;
      static const intmax_t __gcd2 =
        __static_gcd<_R2::num, _R1::den>::value;

    public:
      typedef ratio<
        __safe_multiply<(_R1::num / __gcd1),
                        (_R2::num / __gcd2)>::value,
        __safe_multiply<(_R1::den / __gcd2),
                        (_R2::den / __gcd1)>::value> type;

      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };
# 362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;



  template<typename _R1, typename _R2>
    struct __ratio_divide
    {
      static_assert(_R2::num != 0, "division by 0");

      typedef typename __ratio_multiply<
        _R1,
        ratio<_R2::den, _R2::num>>::type type;

      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };
# 391 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_divide = typename __ratio_divide<_R1, _R2>::type;


  template<typename _R1, typename _R2>
    struct ratio_equal
    : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");
    };


  template<typename _R1, typename _R2>
    struct ratio_not_equal
    : integral_constant<bool, !ratio_equal<_R1, _R2>::value>
    { };




  template<typename _R1, typename _R2,
           typename _Left = __big_mul<_R1::num,_R2::den>,
           typename _Right = __big_mul<_R2::num,_R1::den> >
    struct __ratio_less_impl_1
    : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
           _Right::__hi, _Right::__lo>::value>
    { };

  template<typename _R1, typename _R2,
    bool = (_R1::num == 0 || _R2::num == 0
     || (__static_sign<_R1::num>::value
         != __static_sign<_R2::num>::value)),
    bool = (__static_sign<_R1::num>::value == -1
     && __static_sign<_R2::num>::value == -1)>
    struct __ratio_less_impl
    : __ratio_less_impl_1<_R1, _R2>::type
    { };

  template<typename _R1, typename _R2>
    struct __ratio_less_impl<_R1, _R2, true, false>
    : integral_constant<bool, _R1::num < _R2::num>
    { };

  template<typename _R1, typename _R2>
    struct __ratio_less_impl<_R1, _R2, false, true>
    : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
           ratio<-_R1::num, _R1::den> >::type
    { };




  template<typename _R1, typename _R2>
    struct ratio_less
    : __ratio_less_impl<_R1, _R2>::type
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");
    };


  template<typename _R1, typename _R2>
    struct ratio_less_equal
    : integral_constant<bool, !ratio_less<_R2, _R1>::value>
    { };


  template<typename _R1, typename _R2>
    struct ratio_greater
    : integral_constant<bool, ratio_less<_R2, _R1>::value>
    { };


  template<typename _R1, typename _R2>
    struct ratio_greater_equal
    : integral_constant<bool, !ratio_less<_R1, _R2>::value>
    { };


  template <typename _R1, typename _R2>
    inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_less_equal_v
      = ratio_less_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_greater_equal_v
      = ratio_greater_equal<_R1, _R2>::value;




  template<typename _R1, typename _R2,
      bool = (_R1::num >= 0),
      bool = (_R2::num >= 0),
      bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,
        ratio<__static_abs<_R2::num>::value, _R2::den> >::value>
    struct __ratio_add_impl
    {
    private:
      typedef typename __ratio_add_impl<
        ratio<-_R1::num, _R1::den>,
        ratio<-_R2::num, _R2::den> >::type __t;
    public:
      typedef ratio<-__t::num, __t::den> type;
    };


  template<typename _R1, typename _R2, bool __b>
    struct __ratio_add_impl<_R1, _R2, true, true, __b>
    {
    private:
      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
      static constexpr uintmax_t __d2 = _R2::den / __g;
      typedef __big_mul<_R1::den, __d2> __d;
      typedef __big_mul<_R1::num, _R2::den / __g> __x;
      typedef __big_mul<_R2::num, _R1::den / __g> __y;
      typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
      static_assert(__n::__hi >= __x::__hi, "Internal library error");
      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
      static_assert(__n_final::__rem == 0, "Internal library error");
      static_assert(__n_final::__quot_hi == 0 &&
        __n_final::__quot_lo <= 9223372036854775807L, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 9223372036854775807L, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<typename _R1, typename _R2>
    struct __ratio_add_impl<_R1, _R2, false, true, true>
    : __ratio_add_impl<_R2, _R1>
    { };


  template<typename _R1, typename _R2>
    struct __ratio_add_impl<_R1, _R2, true, false, false>
    {
    private:
      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
      static constexpr uintmax_t __d2 = _R2::den / __g;
      typedef __big_mul<_R1::den, __d2> __d;
      typedef __big_mul<_R1::num, _R2::den / __g> __x;
      typedef __big_mul<-_R2::num, _R1::den / __g> __y;
      typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
      static_assert(__n_final::__rem == 0, "Internal library error");
      static_assert(__n_final::__quot_hi == 0 &&
        __n_final::__quot_lo <= 9223372036854775807L, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 9223372036854775807L, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<typename _R1, typename _R2>
    struct __ratio_add
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");

      typedef typename __ratio_add_impl<_R1, _R2>::type type;
      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };
# 580 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_add = typename __ratio_add<_R1, _R2>::type;



  template<typename _R1, typename _R2>
    struct __ratio_subtract
    {
      typedef typename __ratio_add<
        _R1,
        ratio<-_R2::num, _R2::den>>::type type;

      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };
# 607 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
# 620 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
  using atto = ratio< 1, 1000000000000000000>;
  using femto = ratio< 1, 1000000000000000>;
  using pico = ratio< 1, 1000000000000>;
  using nano = ratio< 1, 1000000000>;
  using micro = ratio< 1, 1000000>;
  using milli = ratio< 1, 1000>;
  using centi = ratio< 1, 100>;
  using deci = ratio< 1, 10>;
  using deca = ratio< 10, 1>;
  using hecto = ratio< 100, 1>;
  using kilo = ratio< 1000, 1>;
  using mega = ratio< 1000000, 1>;
  using giga = ratio< 1000000000, 1>;
  using tera = ratio< 1000000000000, 1>;
  using peta = ratio< 1000000000000000, 1>;
  using exa = ratio< 1000000000000000000, 1>;
# 649 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/ratio" 3
}
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/parse_numbers.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/parse_numbers.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __parse_int
{
  template<unsigned _Base, char _Dig>
    struct _Digit;

  template<unsigned _Base>
    struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
    {
      using __valid = true_type;
    };

  template<unsigned _Base>
    struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
    {
      using __valid = true_type;
    };

  template<unsigned _Base, unsigned _Val>
    struct _Digit_impl : integral_constant<unsigned, _Val>
    {
      static_assert(_Base > _Val, "invalid digit");
      using __valid = true_type;
    };

  template<unsigned _Base>
    struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
    { };


  template<unsigned _Base>
    struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
    {
      using __valid = false_type;
    };



  template<unsigned long long _Val>
    using __ull_constant = integral_constant<unsigned long long, _Val>;

  template<unsigned _Base, char _Dig, char... _Digs>
    struct _Power_help
    {
      using __next = typename _Power_help<_Base, _Digs...>::type;
      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
      using type
 = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
    };

  template<unsigned _Base, char _Dig>
    struct _Power_help<_Base, _Dig>
    {
      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
      using type = __ull_constant<__valid_digit::value>;
    };

  template<unsigned _Base, char... _Digs>
    struct _Power : _Power_help<_Base, _Digs...>::type
    { };

  template<unsigned _Base>
    struct _Power<_Base> : __ull_constant<0>
    { };



  template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
    struct _Number_help
    {
      using __digit = _Digit<_Base, _Dig>;
      using __valid_digit = typename __digit::__valid;
      using __next = _Number_help<_Base,
      __valid_digit::value ? _Pow / _Base : _Pow,
      _Digs...>;
      using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
      static_assert((type::value / _Pow) == __digit::value,
      "integer literal does not fit in unsigned long long");
    };


  template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>
    struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
    : _Number_help<_Base, _Pow, _Dig, _Digs...>
    { };


  template<unsigned _Base, char _Dig>
    struct _Number_help<_Base, 1ULL, _Dig>
    {
      using type = __ull_constant<_Digit<_Base, _Dig>::value>;
    };

  template<unsigned _Base, char... _Digs>
    struct _Number
    : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
    { };

  template<unsigned _Base>
    struct _Number<_Base>
    : __ull_constant<0>
    { };



  template<char... _Digs>
    struct _Parse_int;

  template<char... _Digs>
    struct _Parse_int<'0', 'b', _Digs...>
    : _Number<2U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'B', _Digs...>
    : _Number<2U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'x', _Digs...>
    : _Number<16U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'X', _Digs...>
    : _Number<16U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', _Digs...>
    : _Number<8U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int
    : _Number<10U, _Digs...>::type
    { };

}


namespace __select_int
{
  template<unsigned long long _Val, typename... _Ints>
    struct _Select_int_base;

  template<unsigned long long _Val, typename _IntType, typename... _Ints>
    struct _Select_int_base<_Val, _IntType, _Ints...>
    : __conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max),
        integral_constant<_IntType, (_IntType)_Val>,
        _Select_int_base<_Val, _Ints...>>
    { };

  template<unsigned long long _Val>
    struct _Select_int_base<_Val>
    { };

  template<char... _Digs>
    using _Select_int = typename _Select_int_base<
 __parse_int::_Parse_int<_Digs...>::value,
 unsigned char,
 unsigned short,
 unsigned int,
 unsigned long,
 unsigned long long
      >::type;

}


}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  namespace filesystem { struct __file_clock; };


  namespace chrono
  {




    template<typename _Rep, typename _Period = ratio<1>>
      class duration;


    template<typename _Clock, typename _Dur = typename _Clock::duration>
      class time_point;

  }
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
  template<typename _CT, typename _Period1, typename _Period2, typename = void>
    struct __duration_common_type
    { };

  template<typename _CT, typename _Period1, typename _Period2>
    struct __duration_common_type<_CT, _Period1, _Period2,
      __void_t<typename _CT::type>>
    {
    private:
      using __gcd_num = __static_gcd<_Period1::num, _Period2::num>;
      using __gcd_den = __static_gcd<_Period1::den, _Period2::den>;
      using __cr = typename _CT::type;
      using __r = ratio<__gcd_num::value,
   (_Period1::den / __gcd_den::value) * _Period2::den>;

    public:
      using type = chrono::duration<__cr, typename __r::type>;
    };







  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
    struct common_type<chrono::duration<_Rep1, _Period1>,
         chrono::duration<_Rep2, _Period2>>
    : __duration_common_type<common_type<_Rep1, _Rep2>,
        typename _Period1::type,
        typename _Period2::type>
    { };


  template<typename _Rep, typename _Period>
    struct common_type<chrono::duration<_Rep, _Period>,
         chrono::duration<_Rep, _Period>>
    {
      using type = chrono::duration<typename common_type<_Rep>::type,
        typename _Period::type>;
    };


  template<typename _Rep, typename _Period>
    struct common_type<chrono::duration<_Rep, _Period>>
    {
      using type = chrono::duration<typename common_type<_Rep>::type,
        typename _Period::type>;
    };






  template<typename _CT, typename _Clock, typename = void>
    struct __timepoint_common_type
    { };

  template<typename _CT, typename _Clock>
    struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
    {
      using type = chrono::time_point<_Clock, typename _CT::type>;
    };







  template<typename _Clock, typename _Duration1, typename _Duration2>
    struct common_type<chrono::time_point<_Clock, _Duration1>,
         chrono::time_point<_Clock, _Duration2>>
    : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
    { };


  template<typename _Clock, typename _Duration>
    struct common_type<chrono::time_point<_Clock, _Duration>,
         chrono::time_point<_Clock, _Duration>>
    { using type = chrono::time_point<_Clock, _Duration>; };


  template<typename _Clock, typename _Duration>
    struct common_type<chrono::time_point<_Clock, _Duration>>
    { using type = chrono::time_point<_Clock, _Duration>; };




  namespace chrono
  {






    template<typename _ToDur, typename _CF, typename _CR,
      bool _NumIsOne = false, bool _DenIsOne = false>
      struct __duration_cast_impl
      {
 template<typename _Rep, typename _Period>
   static constexpr _ToDur
   __cast(const duration<_Rep, _Period>& __d)
   {
     typedef typename _ToDur::rep __to_rep;
     return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
       * static_cast<_CR>(_CF::num)
       / static_cast<_CR>(_CF::den)));
   }
      };

    template<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
      {
 template<typename _Rep, typename _Period>
   static constexpr _ToDur
   __cast(const duration<_Rep, _Period>& __d)
   {
     typedef typename _ToDur::rep __to_rep;
     return _ToDur(static_cast<__to_rep>(__d.count()));
   }
      };

    template<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
      {
 template<typename _Rep, typename _Period>
   static constexpr _ToDur
   __cast(const duration<_Rep, _Period>& __d)
   {
     typedef typename _ToDur::rep __to_rep;
     return _ToDur(static_cast<__to_rep>(
       static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
   }
      };

    template<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
      {
 template<typename _Rep, typename _Period>
   static constexpr _ToDur
   __cast(const duration<_Rep, _Period>& __d)
   {
     typedef typename _ToDur::rep __to_rep;
     return _ToDur(static_cast<__to_rep>(
       static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
   }
      };

    template<typename _Tp>
      struct __is_duration
      : std::false_type
      { };

    template<typename _Rep, typename _Period>
      struct __is_duration<duration<_Rep, _Period>>
      : std::true_type
      { };

    template<typename _Tp>
      using __enable_if_is_duration
 = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;

    template<typename _Tp>
      using __disable_if_is_duration
 = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;


    template<typename _Tp>
      inline constexpr bool __is_duration_v = false;
    template<typename _Rep, typename _Period>
      inline constexpr bool __is_duration_v<duration<_Rep, _Period>> = true;
    template<typename _Tp>
      inline constexpr bool __is_time_point_v = false;
    template<typename _Clock, typename _Dur>
      inline constexpr bool __is_time_point_v<time_point<_Clock, _Dur>> = true;
# 276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[__nodiscard__]]
      constexpr __enable_if_is_duration<_ToDur>
      duration_cast(const duration<_Rep, _Period>& __d)
      {

 if constexpr (is_same_v<_ToDur, duration<_Rep, _Period>>)
   return __d;
 else
   {

   using __to_period = typename _ToDur::period;
   using __to_rep = typename _ToDur::rep;
   using __cf = ratio_divide<_Period, __to_period>;
   using __cr = typename common_type<__to_rep, _Rep, intmax_t>::type;
   using __dc = __duration_cast_impl<_ToDur, __cf, __cr,
         __cf::num == 1, __cf::den == 1>;
   return __dc::__cast(__d);

   }

      }
# 310 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep>
      struct treat_as_floating_point
      : is_floating_point<_Rep>
      { };


    template <typename _Rep>
      inline constexpr bool treat_as_floating_point_v =
 treat_as_floating_point<_Rep>::value;

    template<>
      inline constexpr bool treat_as_floating_point_v<int> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<long> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<long long> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<float> = true;
    template<>
      inline constexpr bool treat_as_floating_point_v<double> = true;
    template<>
      inline constexpr bool treat_as_floating_point_v<long double> = true;




    template<typename _Tp>
      inline constexpr bool is_clock_v = false;

    template<typename _Tp>
      requires requires {
 typename _Tp::rep;
 typename _Tp::period;
 typename _Tp::duration;
 typename _Tp::time_point::clock;
 typename _Tp::time_point::duration;
 { &_Tp::is_steady } -> same_as<const bool*>;
 { _Tp::now() } -> same_as<typename _Tp::time_point>;
 requires same_as<typename _Tp::duration,
    duration<typename _Tp::rep, typename _Tp::period>>;
 requires same_as<typename _Tp::time_point::duration,
    typename _Tp::duration>;
      }
    inline constexpr bool is_clock_v<_Tp> = true;
# 373 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Tp>
      struct is_clock
      : bool_constant<is_clock_v<_Tp>>
      { };
# 390 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] constexpr __enable_if_is_duration<_ToDur>
      floor(const duration<_Rep, _Period>& __d)
      {
 auto __to = chrono::duration_cast<_ToDur>(__d);
 if (__to > __d)
   return __to - _ToDur{1};
 return __to;
      }
# 410 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] constexpr __enable_if_is_duration<_ToDur>
      ceil(const duration<_Rep, _Period>& __d)
      {
 auto __to = chrono::duration_cast<_ToDur>(__d);
 if (__to < __d)
   return __to + _ToDur{1};
 return __to;
      }
# 431 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template <typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] constexpr
      enable_if_t<
 __and_<__is_duration<_ToDur>,
        __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
 _ToDur>
      round(const duration<_Rep, _Period>& __d)
      {
 _ToDur __t0 = chrono::floor<_ToDur>(__d);
 _ToDur __t1 = __t0 + _ToDur{1};
 auto __diff0 = __d - __t0;
 auto __diff1 = __t1 - __d;
 if (__diff0 == __diff1)
   {
     if (__t0.count() & 1)
       return __t1;
     return __t0;
   }
 else if (__diff0 < __diff1)
   return __t0;
 return __t1;
      }







    template<typename _Rep, typename _Period>
      [[nodiscard]] constexpr
      enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
      abs(duration<_Rep, _Period> __d)
      {
 if (__d >= __d.zero())
   return __d;
 return -__d;
      }


    namespace __detail { using chrono::ceil; }
# 498 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep>
      struct duration_values
      {
 static constexpr _Rep
 zero() noexcept
 { return _Rep(0); }

 static constexpr _Rep
 max() noexcept
 { return numeric_limits<_Rep>::max(); }

 static constexpr _Rep
 min() noexcept
 { return numeric_limits<_Rep>::lowest(); }
      };

    template<typename _Rep, typename _Period>
      class duration
      {
 static_assert(!__is_duration<_Rep>::value,
        "rep cannot be a std::chrono::duration");
 static_assert(__is_ratio<_Period>::value,
        "period must be a specialization of std::ratio");
 static_assert(_Period::num > 0, "period must be positive");

 template<typename _Rep2>
   using __is_float = treat_as_floating_point<_Rep2>;

 static constexpr intmax_t
 _S_gcd(intmax_t __m, intmax_t __n) noexcept
 {



   do
     {
       intmax_t __rem = __m % __n;
       __m = __n;
       __n = __rem;
     }
   while (__n != 0);
   return __m;





 }





 template<typename _R1, typename _R2,
   intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num),
   intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)>
   using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2),
     (_R1::den / __gcd2) * (_R2::num / __gcd1)>;


 template<typename _Period2>
   using __is_harmonic
     = __bool_constant<__divide<_Period2, _Period>::den == 1>;

      public:

 using rep = _Rep;
 using period = typename _Period::type;


 constexpr duration() = default;

 duration(const duration&) = default;



 template<typename _Rep2, typename = _Require<
   is_convertible<const _Rep2&, rep>,
   __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
   constexpr explicit duration(const _Rep2& __rep)
   : __r(static_cast<rep>(__rep)) { }

 template<typename _Rep2, typename _Period2, typename = _Require<
   is_convertible<const _Rep2&, rep>,
   __or_<__is_float<rep>,
         __and_<__is_harmonic<_Period2>,
         __not_<__is_float<_Rep2>>>>>>
   constexpr duration(const duration<_Rep2, _Period2>& __d)
   : __r(duration_cast<duration>(__d).count()) { }

 ~duration() = default;
 duration& operator=(const duration&) = default;


 constexpr rep
 count() const
 { return __r; }



 constexpr duration<typename common_type<rep>::type, period>
 operator+() const
 { return duration<typename common_type<rep>::type, period>(__r); }

 constexpr duration<typename common_type<rep>::type, period>
 operator-() const
 { return duration<typename common_type<rep>::type, period>(-__r); }

 constexpr duration&
 operator++()
 {
   ++__r;
   return *this;
 }

 constexpr duration
 operator++(int)
 { return duration(__r++); }

 constexpr duration&
 operator--()
 {
   --__r;
   return *this;
 }

 constexpr duration
 operator--(int)
 { return duration(__r--); }

 constexpr duration&
 operator+=(const duration& __d)
 {
   __r += __d.count();
   return *this;
 }

 constexpr duration&
 operator-=(const duration& __d)
 {
   __r -= __d.count();
   return *this;
 }

 constexpr duration&
 operator*=(const rep& __rhs)
 {
   __r *= __rhs;
   return *this;
 }

 constexpr duration&
 operator/=(const rep& __rhs)
 {
   __r /= __rhs;
   return *this;
 }


 template<typename _Rep2 = rep>
   constexpr
   __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&>
   operator%=(const rep& __rhs)
   {
     __r %= __rhs;
     return *this;
   }

 template<typename _Rep2 = rep>
   constexpr
   __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&>
   operator%=(const duration& __d)
   {
     __r %= __d.count();
     return *this;
   }


 static constexpr duration
 zero() noexcept
 { return duration(duration_values<rep>::zero()); }

 static constexpr duration
 min() noexcept
 { return duration(duration_values<rep>::min()); }

 static constexpr duration
 max() noexcept
 { return duration(duration_values<rep>::max()); }

      private:
 rep __r;
      };





    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         duration<_Rep2, _Period2>>::type
      operator+(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __cd;
 return __cd(__cd(__lhs).count() + __cd(__rhs).count());
      }


    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         duration<_Rep2, _Period2>>::type
      operator-(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __cd;
 return __cd(__cd(__lhs).count() - __cd(__rhs).count());
      }
# 731 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep1, typename _Rep2,
      typename _CRep = typename common_type<_Rep1, _Rep2>::type>
      using __common_rep_t = typename
 enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
# 743 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep1, typename _Period, typename _Rep2>
      constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() * __s);
      }

    template<typename _Rep1, typename _Rep2, typename _Period>
      constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
      { return __d * __s; }

    template<typename _Rep1, typename _Period, typename _Rep2>
      constexpr
      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() / __s);
      }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<_Rep1, _Rep2>::type
      operator/(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __cd;
 return __cd(__lhs).count() / __cd(__rhs).count();
      }


    template<typename _Rep1, typename _Period, typename _Rep2>
      constexpr
      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() % __s);
      }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         duration<_Rep2, _Period2>>::type
      operator%(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __cd;
 return __cd(__cd(__lhs).count() % __cd(__rhs).count());
      }
# 811 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator==(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __ct;
 return __ct(__lhs).count() == __ct(__rhs).count();
      }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator<(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<__dur1,__dur2>::type __ct;
 return __ct(__lhs).count() < __ct(__rhs).count();
      }


    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
      constexpr auto
      operator<=>(const duration<_Rep1, _Period1>& __lhs,
    const duration<_Rep2, _Period2>& __rhs)
      {
 using __ct = common_type_t<duration<_Rep1, _Period1>,
       duration<_Rep2, _Period2>>;
 return __ct(__lhs).count() <=> __ct(__rhs).count();
      }
# 856 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator<=(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      { return !(__rhs < __lhs); }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator>(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      { return __rhs < __lhs; }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator>=(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      { return !(__lhs < __rhs); }
# 892 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    using nanoseconds = duration<int64_t, nano>;


    using microseconds = duration<int64_t, micro>;


    using milliseconds = duration<int64_t, milli>;


    using seconds = duration<int64_t>;


    using minutes = duration<int64_t, ratio< 60>>;


    using hours = duration<int64_t, ratio<3600>>;



    using days = duration<int64_t, ratio<86400>>;


    using weeks = duration<int64_t, ratio<604800>>;


    using years = duration<int64_t, ratio<31556952>>;


    using months = duration<int64_t, ratio<2629746>>;




    template<typename _Clock, typename _Dur>
      class time_point
      {
 static_assert(__is_duration<_Dur>::value,
     "duration must be a specialization of std::chrono::duration");

      public:
 typedef _Clock clock;
 typedef _Dur duration;
 typedef typename duration::rep rep;
 typedef typename duration::period period;

 constexpr time_point() : __d(duration::zero())
 { }

 constexpr explicit time_point(const duration& __dur)
 : __d(__dur)
 { }


 template<typename _Dur2,
   typename = _Require<is_convertible<_Dur2, _Dur>>>
   constexpr time_point(const time_point<clock, _Dur2>& __t)
   : __d(__t.time_since_epoch())
   { }


 constexpr duration
 time_since_epoch() const
 { return __d; }


 constexpr time_point&
 operator++()
 {
   ++__d;
   return *this;
 }

 constexpr time_point
 operator++(int)
 { return time_point{__d++}; }

 constexpr time_point&
 operator--()
 {
   --__d;
   return *this;
 }

 constexpr time_point
 operator--(int)
 { return time_point{__d--}; }



 constexpr time_point&
 operator+=(const duration& __dur)
 {
   __d += __dur;
   return *this;
 }

 constexpr time_point&
 operator-=(const duration& __dur)
 {
   __d -= __dur;
   return *this;
 }


 static constexpr time_point
 min() noexcept
 { return time_point(duration::min()); }

 static constexpr time_point
 max() noexcept
 { return time_point(duration::max()); }

      private:
 duration __d;
      };
# 1020 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[__nodiscard__]] constexpr
      __enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
      time_point_cast(const time_point<_Clock, _Dur>& __t)
      {
 typedef time_point<_Clock, _ToDur> __time_point;
 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
      }
# 1042 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>>
      floor(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::floor<_ToDur>(__tp.time_since_epoch())};
      }
# 1063 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>>
      ceil(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::ceil<_ToDur>(__tp.time_since_epoch())};
      }
# 1085 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>
      && !treat_as_floating_point_v<typename _ToDur::rep>,
    time_point<_Clock, _ToDur>>
      round(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::round<_ToDur>(__tp.time_since_epoch())};
      }






    template<typename _Clock, typename _Dur1,
      typename _Rep2, typename _Period2>
      constexpr time_point<_Clock,
 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
      operator+(const time_point<_Clock, _Dur1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<_Dur1,__dur2>::type __ct;
 typedef time_point<_Clock, __ct> __time_point;
 return __time_point(__lhs.time_since_epoch() + __rhs);
      }


    template<typename _Rep1, typename _Period1,
      typename _Clock, typename _Dur2>
      constexpr time_point<_Clock,
 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
      operator+(const duration<_Rep1, _Period1>& __lhs,
  const time_point<_Clock, _Dur2>& __rhs)
      {
 typedef duration<_Rep1, _Period1> __dur1;
 typedef typename common_type<__dur1,_Dur2>::type __ct;
 typedef time_point<_Clock, __ct> __time_point;
 return __time_point(__rhs.time_since_epoch() + __lhs);
      }


    template<typename _Clock, typename _Dur1,
      typename _Rep2, typename _Period2>
      constexpr time_point<_Clock,
 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
      operator-(const time_point<_Clock, _Dur1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      {
 typedef duration<_Rep2, _Period2> __dur2;
 typedef typename common_type<_Dur1,__dur2>::type __ct;
 typedef time_point<_Clock, __ct> __time_point;
 return __time_point(__lhs.time_since_epoch() -__rhs);
      }


    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr typename common_type<_Dur1, _Dur2>::type
      operator-(const time_point<_Clock, _Dur1>& __lhs,
  const time_point<_Clock, _Dur2>& __rhs)
      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }







    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator==(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }


    template<typename _Clock, typename _Dur1,
      three_way_comparable_with<_Dur1> _Dur2>
      constexpr auto
      operator<=>(const time_point<_Clock, _Dur1>& __lhs,
    const time_point<_Clock, _Dur2>& __rhs)
      { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); }
# 1176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator<(const time_point<_Clock, _Dur1>& __lhs,
  const time_point<_Clock, _Dur2>& __rhs)
      { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }

    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator<=(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return !(__rhs < __lhs); }

    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator>(const time_point<_Clock, _Dur1>& __lhs,
  const time_point<_Clock, _Dur2>& __rhs)
      { return __rhs < __lhs; }

    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator>=(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return !(__lhs < __rhs); }
# 1222 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
inline namespace _V2 {







    struct system_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<system_clock, duration> time_point;

      static_assert(system_clock::duration::min()
      < system_clock::duration::zero(),
      "a clock's minimum duration cannot be less than its epoch");

      static constexpr bool is_steady = false;

      static time_point
      now() noexcept;


      [[__gnu__::__always_inline__]]
      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());
      }

      [[__gnu__::__always_inline__]]
      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)));
      }
    };
# 1272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    struct steady_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<steady_clock, duration> time_point;

      static constexpr bool is_steady = true;

      static time_point
      now() noexcept;
    };
# 1294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
    using high_resolution_clock = system_clock;

}




    template<typename _Duration>
      using sys_time = time_point<system_clock, _Duration>;
    using sys_seconds = sys_time<seconds>;
    using sys_days = sys_time<days>;

    using file_clock = ::std::filesystem::__file_clock;

    template<typename _Duration>
      using file_time = time_point<file_clock, _Duration>;

    template<> struct is_clock<system_clock> : true_type { };
    template<> struct is_clock<steady_clock> : true_type { };
    template<> struct is_clock<file_clock> : true_type { };

    template<> inline constexpr bool is_clock_v<system_clock> = true;
    template<> inline constexpr bool is_clock_v<steady_clock> = true;
    template<> inline constexpr bool is_clock_v<file_clock> = true;
# 1329 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
  }


  inline namespace literals
  {
# 1358 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono.h" 3
  inline namespace chrono_literals
  {



#pragma GCC diagnostic push


    template<typename _Dur, char... _Digits>
      constexpr _Dur __check_overflow()
      {
 using _Val = __parse_int::_Parse_int<_Digits...>;
 constexpr typename _Dur::rep __repval = _Val::value;
 static_assert(__repval >= 0 && __repval == _Val::value,
        "literal value cannot be represented by duration type");
 return _Dur(__repval);
      }



    constexpr chrono::duration<long double, ratio<3600,1>>
    operator""h(long double __hours)
    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }


    template <char... _Digits>
      constexpr chrono::hours
      operator""h()
      { return __check_overflow<chrono::hours, _Digits...>(); }


    constexpr chrono::duration<long double, ratio<60,1>>
    operator""min(long double __mins)
    { return chrono::duration<long double, ratio<60,1>>{__mins}; }


    template <char... _Digits>
      constexpr chrono::minutes
      operator""min()
      { return __check_overflow<chrono::minutes, _Digits...>(); }


    constexpr chrono::duration<long double>
    operator""s(long double __secs)
    { return chrono::duration<long double>{__secs}; }


    template <char... _Digits>
      constexpr chrono::seconds
      operator""s()
      { return __check_overflow<chrono::seconds, _Digits...>(); }


    constexpr chrono::duration<long double, milli>
    operator""ms(long double __msecs)
    { return chrono::duration<long double, milli>{__msecs}; }


    template <char... _Digits>
      constexpr chrono::milliseconds
      operator""ms()
      { return __check_overflow<chrono::milliseconds, _Digits...>(); }


    constexpr chrono::duration<long double, micro>
    operator""us(long double __usecs)
    { return chrono::duration<long double, micro>{__usecs}; }


    template <char... _Digits>
      constexpr chrono::microseconds
      operator""us()
      { return __check_overflow<chrono::microseconds, _Digits...>(); }


    constexpr chrono::duration<long double, nano>
    operator""ns(long double __nsecs)
    { return chrono::duration<long double, nano>{__nsecs}; }


    template <char... _Digits>
      constexpr chrono::nanoseconds
      operator""ns()
      { return __check_overflow<chrono::nanoseconds, _Digits...>(); }

#pragma GCC diagnostic pop

  }
  }

  namespace chrono
  {
    using namespace literals::chrono_literals;
  }



  namespace filesystem
  {
    struct __file_clock
    {
      using duration = chrono::nanoseconds;
      using rep = duration::rep;
      using period = duration::period;
      using time_point = chrono::time_point<__file_clock>;
      static constexpr bool is_steady = false;

      static time_point
      now() noexcept
      { return _S_from_sys(chrono::system_clock::now()); }


      template<typename _Dur>
 static
 chrono::file_time<common_type_t<_Dur, chrono::seconds>>
 from_sys(const chrono::sys_time<_Dur>& __t) noexcept
 { return _S_from_sys(__t); }


      template<typename _Dur>
 static
 chrono::sys_time<common_type_t<_Dur, chrono::seconds>>
 to_sys(const chrono::file_time<_Dur>& __t) noexcept
 { return _S_to_sys(__t); }


    private:
      using __sys_clock = chrono::system_clock;




      static constexpr chrono::seconds _S_epoch_diff{6437664000};

    protected:

      template<typename _Dur>
 static
 chrono::time_point<__file_clock, common_type_t<_Dur, chrono::seconds>>
 _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept
 {
   using _CDur = common_type_t<_Dur, chrono::seconds>;
   using __file_time = chrono::time_point<__file_clock, _CDur>;
   return __file_time{__t.time_since_epoch()} - _S_epoch_diff;
 }


      template<typename _Dur>
 static
 chrono::time_point<__sys_clock, common_type_t<_Dur, chrono::seconds>>
 _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept
 {
   using _CDur = common_type_t<_Dur, chrono::seconds>;
   using __sys_time = chrono::time_point<__sys_clock, _CDur>;
   return __sys_time{__t.time_since_epoch()} + _S_epoch_diff;
 }
    };
  }



}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_lock.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_lock.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unique_lock.h" 3
  template<typename _Mutex>
    class unique_lock
    {
    public:
      typedef _Mutex mutex_type;

      unique_lock() noexcept
      : _M_device(0), _M_owns(false)
      { }

      [[__nodiscard__]]
      explicit unique_lock(mutex_type& __m)
      : _M_device(std::__addressof(__m)), _M_owns(false)
      {
 lock();
 _M_owns = true;
      }

      unique_lock(mutex_type& __m, defer_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(false)
      { }

      [[__nodiscard__]]
      unique_lock(mutex_type& __m, try_to_lock_t)
      : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock())
      { }

      [[__nodiscard__]]
      unique_lock(mutex_type& __m, adopt_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(true)
      {

      }

      template<typename _Clock, typename _Duration>
 [[__nodiscard__]]
 unique_lock(mutex_type& __m,
      const chrono::time_point<_Clock, _Duration>& __atime)
 : _M_device(std::__addressof(__m)),
   _M_owns(_M_device->try_lock_until(__atime))
 { }

      template<typename _Rep, typename _Period>
 [[__nodiscard__]]
 unique_lock(mutex_type& __m,
      const chrono::duration<_Rep, _Period>& __rtime)
 : _M_device(std::__addressof(__m)),
   _M_owns(_M_device->try_lock_for(__rtime))
 { }

      ~unique_lock()
      {
 if (_M_owns)
   unlock();
      }

      unique_lock(const unique_lock&) = delete;
      unique_lock& operator=(const unique_lock&) = delete;

      unique_lock(unique_lock&& __u) noexcept
      : _M_device(__u._M_device), _M_owns(__u._M_owns)
      {
 __u._M_device = 0;
 __u._M_owns = false;
      }

      unique_lock& operator=(unique_lock&& __u) noexcept
      {


 unique_lock(std::move(__u)).swap(*this);
 return *this;
      }

      void
      lock()
      {
 if (!_M_device)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
 else
   {
     _M_device->lock();
     _M_owns = true;
   }
      }

      [[__nodiscard__]]
      bool
      try_lock()
      {
 if (!_M_device)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
 else
   {
     _M_owns = _M_device->try_lock();
     return _M_owns;
   }
      }

      template<typename _Clock, typename _Duration>
 [[__nodiscard__]]
 bool
 try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
 {
   if (!_M_device)
     __throw_system_error(int(errc::operation_not_permitted));
   else if (_M_owns)
     __throw_system_error(int(errc::resource_deadlock_would_occur));
   else
     {
       _M_owns = _M_device->try_lock_until(__atime);
       return _M_owns;
     }
 }

      template<typename _Rep, typename _Period>
 [[__nodiscard__]]
 bool
 try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
 {
   if (!_M_device)
     __throw_system_error(int(errc::operation_not_permitted));
   else if (_M_owns)
     __throw_system_error(int(errc::resource_deadlock_would_occur));
   else
     {
       _M_owns = _M_device->try_lock_for(__rtime);
       return _M_owns;
     }
  }

      void
      unlock()
      {
 if (!_M_owns)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_device)
   {
     _M_device->unlock();
     _M_owns = false;
   }
      }

      void
      swap(unique_lock& __u) noexcept
      {
 std::swap(_M_device, __u._M_device);
 std::swap(_M_owns, __u._M_owns);
      }

      mutex_type*
      release() noexcept
      {
 mutex_type* __ret = _M_device;
 _M_device = 0;
 _M_owns = false;
 return __ret;
      }

      [[__nodiscard__]]
      bool
      owns_lock() const noexcept
      { return _M_owns; }

      explicit operator bool() const noexcept
      { return owns_lock(); }

      [[__nodiscard__]]
      mutex_type*
      mutex() const noexcept
      { return _M_device; }

    private:
      mutex_type* _M_device;
      bool _M_owns;
    };



  template<typename _Mutex>
    inline void
    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }


}
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 2 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 63 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 77 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;
# 101 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  };
# 113 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  class recursive_mutex : private __recursive_mutex_base
  {
  public:
    typedef __native_type* native_handle_type;

    recursive_mutex() = default;
    ~recursive_mutex() = default;

    recursive_mutex(const recursive_mutex&) = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_recursive_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }

    void
    unlock()
    {

      __gthread_recursive_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };




  template<typename _Derived>
    class __timed_mutex_impl
    {
    protected:
      template<typename _Rep, typename _Period>
 bool
 _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
 {

   using __clock = chrono::steady_clock;




   auto __rt = chrono::duration_cast<__clock::duration>(__rtime);
   if (ratio_greater<__clock::period, _Period>())
     ++__rt;
   return _M_try_lock_until(__clock::now() + __rt);
 }

      template<typename _Duration>
 bool
 _M_try_lock_until(const chrono::time_point<chrono::system_clock,
         _Duration>& __atime)
 {
   auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
   auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

   __gthread_time_t __ts = {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

   return static_cast<_Derived*>(this)->_M_timedlock(__ts);
 }


      template<typename _Duration>
 bool
 _M_try_lock_until(const chrono::time_point<chrono::steady_clock,
         _Duration>& __atime)
 {
   auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
   auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

   __gthread_time_t __ts = {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

   return static_cast<_Derived*>(this)->_M_clocklock(1,
           __ts);
 }


      template<typename _Clock, typename _Duration>
 bool
 _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
 {

   static_assert(chrono::is_clock_v<_Clock>);




   auto __now = _Clock::now();
   do {
     auto __rtime = __atime - __now;
     if (_M_try_lock_for(__rtime))
       return true;
     __now = _Clock::now();
   } while (__atime > __now);
   return false;
 }
    };
# 242 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  class timed_mutex
  : private __mutex_base, public __timed_mutex_impl<timed_mutex>
  {
  public:
    typedef __native_type* native_handle_type;

    timed_mutex() = default;
    ~timed_mutex() = default;

    timed_mutex(const timed_mutex&) = delete;
    timed_mutex& operator=(const timed_mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      [[__nodiscard__]]
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      [[__nodiscard__]]
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      { return _M_try_lock_until(__atime); }

    void
    unlock()
    {

      __gthread_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }

    private:
      friend class __timed_mutex_impl<timed_mutex>;

      bool
      _M_timedlock(const __gthread_time_t& __ts)
      { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); }


      bool
      _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts)
      { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); }

  };
# 319 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  class recursive_timed_mutex
  : private __recursive_mutex_base,
    public __timed_mutex_impl<recursive_timed_mutex>
  {
  public:
    typedef __native_type* native_handle_type;

    recursive_timed_mutex() = default;
    ~recursive_timed_mutex() = default;

    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;

    void
    lock()
    {
      int __e = __gthread_recursive_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      [[__nodiscard__]]
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      [[__nodiscard__]]
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      { return _M_try_lock_until(__atime); }

    void
    unlock()
    {

      __gthread_recursive_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }

    private:
      friend class __timed_mutex_impl<recursive_timed_mutex>;

      bool
      _M_timedlock(const __gthread_time_t& __ts)
      { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); }


      bool
      _M_clocklock(clockid_t __clockid, const __gthread_time_t& __ts)
      { return !pthread_mutex_clocklock(&_M_mutex, __clockid, &__ts); }

  };
# 566 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  namespace __detail
  {

    template<typename _Lockable>
      inline int
      __try_lock_impl(_Lockable& __l)
      {
 if (unique_lock<_Lockable> __lock{__l, try_to_lock})
   {
     __lock.release();
     return -1;
   }
 else
   return 0;
      }



    template<typename _L0, typename... _Lockables>
      inline int
      __try_lock_impl(_L0& __l0, _Lockables&... __lockables)
      {

 if constexpr ((is_same_v<_L0, _Lockables> && ...))
   {
     constexpr int _Np = 1 + sizeof...(_Lockables);
     unique_lock<_L0> __locks[_Np] = {
  {__l0, defer_lock}, {__lockables, defer_lock}...
     };
     for (int __i = 0; __i < _Np; ++__i)
       {
  if (!__locks[__i].try_lock())
    {
      const int __failed = __i;
      while (__i--)
        __locks[__i].unlock();
      return __failed;
    }
       }
     for (auto& __l : __locks)
       __l.release();
     return -1;
   }
 else

 if (unique_lock<_L0> __lock{__l0, try_to_lock})
   {
     int __idx = __detail::__try_lock_impl(__lockables...);
     if (__idx == -1)
       {
  __lock.release();
  return -1;
       }
     return __idx + 1;
   }
 else
   return 0;
      }

  }
# 638 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  template<typename _L1, typename _L2, typename... _L3>
    [[__nodiscard__]]
    inline int
    try_lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {
      return __detail::__try_lock_impl(__l1, __l2, __l3...);
    }


  namespace __detail
  {





    template<typename _L0, typename... _L1>
      void
      __lock_impl(int& __i, int __depth, _L0& __l0, _L1&... __l1)
      {
 while (__i >= __depth)
   {
     if (__i == __depth)
       {
  int __failed = 1;
  {
    unique_lock<_L0> __first(__l0);
    __failed += __detail::__try_lock_impl(__l1...);
    if (!__failed)
      {
        __i = -1;
        __first.release();
        return;
      }
  }

  __gthread_yield();

  constexpr auto __n = 1 + sizeof...(_L1);
  __i = (__depth + __failed) % __n;
       }
     else
       __detail::__lock_impl(__i, __depth + 1, __l1..., __l0);
   }
      }

  }
# 698 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  template<typename _L1, typename _L2, typename... _L3>
    void
    lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {

      if constexpr (is_same_v<_L1, _L2> && (is_same_v<_L1, _L3> && ...))
 {
   constexpr int _Np = 2 + sizeof...(_L3);
   unique_lock<_L1> __locks[] = {
       {__l1, defer_lock}, {__l2, defer_lock}, {__l3, defer_lock}...
   };
   int __first = 0;
   do {
     __locks[__first].lock();
     for (int __j = 1; __j < _Np; ++__j)
       {
  const int __idx = (__first + __j) % _Np;
  if (!__locks[__idx].try_lock())
    {
      for (int __k = __j; __k != 0; --__k)
        __locks[(__first + __k - 1) % _Np].unlock();
      __first = __idx;
      break;
    }
       }
   } while (!__locks[__first].owns_lock());

   for (auto& __l : __locks)
     __l.release();
 }
      else

 {
   int __i = 0;
   __detail::__lock_impl(__i, 0, __l1, __l2, __l3...);
 }
    }
# 745 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  template<typename... _MutexTypes>
    class scoped_lock
    {
    public:

      [[nodiscard]]
      explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...))
      { std::lock(__m...); }

      [[nodiscard]]
      explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept
      : _M_devices(std::tie(__m...))
      { }

      ~scoped_lock()
      { std::apply([](auto&... __m) { (__m.unlock(), ...); }, _M_devices); }

      scoped_lock(const scoped_lock&) = delete;
      scoped_lock& operator=(const scoped_lock&) = delete;

    private:
      tuple<_MutexTypes&...> _M_devices;
    };

  template<>
    class scoped_lock<>
    {
    public:
      explicit scoped_lock() = default;
      explicit scoped_lock(adopt_lock_t) noexcept { }
      ~scoped_lock() = default;

      scoped_lock(const scoped_lock&) = delete;
      scoped_lock& operator=(const scoped_lock&) = delete;
    };

  template<typename _Mutex>
    class scoped_lock<_Mutex>
    {
    public:
      using mutex_type = _Mutex;

      [[nodiscard]]
      explicit scoped_lock(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      [[nodiscard]]
      explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept
      : _M_device(__m)
      { }

      ~scoped_lock()
      { _M_device.unlock(); }

      scoped_lock(const scoped_lock&) = delete;
      scoped_lock& operator=(const scoped_lock&) = delete;

    private:
      mutex_type& _M_device;
    };




  struct once_flag
  {
    constexpr once_flag() noexcept = default;


    once_flag(const once_flag&) = delete;

    once_flag& operator=(const once_flag&) = delete;

  private:


    __gthread_once_t _M_once = 0;

    struct _Prepare_execution;

    template<typename _Callable, typename... _Args>
      friend void
      call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
  };





  extern __thread void* __once_callable;
  extern __thread void (*__once_call)();


  struct once_flag::_Prepare_execution
  {
    template<typename _Callable>
      explicit
      _Prepare_execution(_Callable& __c)
      {

 __once_callable = std::__addressof(__c);

 __once_call = [] { (*static_cast<_Callable*>(__once_callable))(); };
      }

    ~_Prepare_execution()
    {

      __once_callable = nullptr;
      __once_call = nullptr;
    }

    _Prepare_execution(const _Prepare_execution&) = delete;
    _Prepare_execution& operator=(const _Prepare_execution&) = delete;
  };
# 902 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
  extern "C" void __once_proxy(void);


  template<typename _Callable, typename... _Args>
    void
    call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
    {

      auto __callable = [&] {
   std::__invoke(std::forward<_Callable>(__f),
   std::forward<_Args>(__args)...);
      };

      once_flag::_Prepare_execution __exec(__callable);


      if (int __e = __gthread_once(&__once._M_once, &__once_proxy))
 __throw_system_error(__e);
    }
# 1024 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/mutex" 3
}
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4EnvironmentUtils.hh" 2 3








class G4EnvSettings
{



 public:
  using string_t = std::string;
  using env_map_t = std::map<string_t, string_t>;
  using env_pair_t = std::pair<string_t, string_t>;

  static G4EnvSettings* GetInstance()
  {
    static auto* _instance = new G4EnvSettings();
    return _instance;
  }

  template <typename _Tp>
  void insert(const std::string& env_id, _Tp val)
  {
    std::stringstream ss;
    ss << val;


    static std::mutex _mutex;
    _mutex.lock();
    m_env.insert(env_pair_t(env_id, ss.str()));
    _mutex.unlock();
  }

  const env_map_t& get() const { return m_env; }

  friend std::ostream& operator<<(std::ostream& os, const G4EnvSettings& env)
  {
    std::stringstream filler;
    filler.fill('#');
    filler << std::setw(90) << "";
    std::stringstream ss;
    ss << filler.str() << "\n# Environment settings:\n";
    for(const auto& itr : env.get())
    {
      ss << "# " << std::setw(35) << std::right << itr.first << "\t = \t"
         << std::left << itr.second << "\n";
    }
    ss << filler.str();
    os << ss.str() << std::endl;
    return os;
  }

 private:
  env_map_t m_env;
};







template <typename _Tp>
_Tp G4GetEnv(const std::string& env_id, _Tp _default = _Tp())
{
  char* env_var = std::getenv(env_id.c_str());
  if(env_var)
  {
    std::string str_var = std::string(env_var);
    std::istringstream iss(str_var);
    _Tp var = _Tp();
    iss >> var;

    G4EnvSettings::GetInstance()->insert<_Tp>(env_id, var);
    return var;
  }

  G4EnvSettings::GetInstance()->insert<_Tp>(env_id, _default);


  return _default;
}







template <>
inline G4bool G4GetEnv(const std::string& env_id, bool _default)
{
  char* env_var = std::getenv(env_id.c_str());
  if(env_var != nullptr)
  {

    G4EnvSettings::GetInstance()->insert<bool>(env_id, true);
    return true;
  }

  G4EnvSettings::GetInstance()->insert<bool>(env_id, false);


  return _default;
}
# 166 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4EnvironmentUtils.hh" 3
template <typename _Tp>
_Tp G4GetEnv(const std::string& env_id, _Tp _default, const std::string& msg)
{
  char* env_var = std::getenv(env_id.c_str());
  if(env_var)
  {
    std::string str_var = std::string(env_var);
    std::istringstream iss(str_var);
    _Tp var = _Tp();
    iss >> var;
    G4cout << "Environment variable \"" << env_id << "\" enabled with "
           << "value == " << var << ". " << msg << std::endl;

    G4EnvSettings::GetInstance()->insert<_Tp>(env_id, var);
    return var;
  }

  G4EnvSettings::GetInstance()->insert<_Tp>(env_id, _default);


  return _default;
}
# 198 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4EnvironmentUtils.hh" 3
inline G4String G4GetDataEnv(const std::string& env_id,
                             const char* originOfException,
                             const char* exceptionCode,
                             G4ExceptionSeverity severity,
                             const char* description)
{
  char* env_var = std::getenv(env_id.c_str());
  if(env_var != nullptr)
  {
    std::string str_var = std::string(env_var);
    std::istringstream iss(str_var);
    G4String var = "";
    iss >> var;

    G4EnvSettings::GetInstance()->insert<G4String>(env_id, var);
    return var;
  }


  G4Exception(originOfException, exceptionCode, severity, description);


  return "";
}

const char* G4FindDataDir(const char*);




inline void G4PrintEnv(std::ostream& os = G4cout)
{
  os << (*G4EnvSettings::GetInstance());
}
# 60 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/globals.hh" 2 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VUserTrackInformation.hh" 2 3

class G4VUserTrackInformation
{
  public:

    G4VUserTrackInformation() = default;
    G4VUserTrackInformation(const G4String& infoType);



    G4VUserTrackInformation(const G4VUserTrackInformation&);
    G4VUserTrackInformation& operator=(const G4VUserTrackInformation&);

    virtual ~G4VUserTrackInformation();

    virtual void Print() const {};

    const G4String& GetType() const;


  protected:

    G4String* pType = nullptr;
};
# 16 "include/simulation/kernel/UserInfo.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VUserPrimaryParticleInformation.hh" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VUserPrimaryParticleInformation.hh" 3
class G4VUserPrimaryParticleInformation
{
  public:
    G4VUserPrimaryParticleInformation() = default;
    virtual ~G4VUserPrimaryParticleInformation() = default;

    virtual void Print() const = 0;
};
# 17 "include/simulation/kernel/UserInfo.h" 2


namespace Belle2 {

  namespace Simulation {



    class CouldNotFindUserInfo : public std::runtime_error { public: CouldNotFindUserInfo(): std::runtime_error(""), m_format("No User Information was found !") { } ~CouldNotFindUserInfo() noexcept {} virtual const char * what() const noexcept override { m_finalStr = m_format.str(); return m_finalStr.c_str(); } template <class T> CouldNotFindUserInfo& operator<<(const T& param) { m_format % param; return *this; } private: boost::format m_format; mutable std::string m_finalStr; };;





    template<class Info, class Payload> class UserInfo: public Info {

    public:





      explicit UserInfo(Payload data) : Info(), m_data(data), m_status(0), m_fraction(1.0), m_trajectory(nullptr) {}





      Payload getData() { return m_data; }
# 54 "include/simulation/kernel/UserInfo.h"
      int getStatus() {return m_status;}
# 63 "include/simulation/kernel/UserInfo.h"
      double getFraction() {return m_fraction;}


      MCParticleTrajectory* getTrajectory() { return m_trajectory; }





      void setStatus(int status) { m_status = status;}





      void setFraction(double fraction) { m_fraction = fraction;}


      void setTrajectory(MCParticleTrajectory* trajectory) { m_trajectory = trajectory; }




      virtual void Print() const {;}
# 95 "include/simulation/kernel/UserInfo.h"
      template<class Carrier> static Payload getInfo(Carrier& obj)
      {
        UserInfo<Info, Payload>* userinfo = dynamic_cast<UserInfo<Info, Payload>*>(obj.GetUserInformation());
        if (!userinfo) throw(CouldNotFindUserInfo());
        return userinfo->getData();
      }

    protected:

      Payload m_data;

      int m_status;
      double m_fraction;
      MCParticleTrajectory* m_trajectory;

    };

    typedef UserInfo< G4VUserTrackInformation, MCParticleGraph::GraphParticle& > TrackInfo;
    typedef UserInfo< G4VUserPrimaryParticleInformation, MCParticleGraph::GraphParticle& > ParticleInfo;

  }
}
# 13 "include/simulation/kernel/SensitiveDetectorBase.h" 2
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4CollectionNameVector.hh" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4CollectionNameVector.hh" 3
class G4CollectionNameVector : public std::vector<G4String>
{
 public:
  G4CollectionNameVector() {}
  virtual ~G4CollectionNameVector() {}

  void insert(G4String str) { push_back(str); }
};
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4HCofThisEvent.hh" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4HCofThisEvent.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Allocator.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Allocator.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AllocatorPool.hh" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AllocatorPool.hh" 3
class G4AllocatorPool
{
 public:
  explicit G4AllocatorPool(unsigned int n = 0);

  ~G4AllocatorPool();


  G4AllocatorPool(const G4AllocatorPool& right) = default;

  G4AllocatorPool& operator=(const G4AllocatorPool& right);


  inline void* Alloc();

  inline void Free(void* b);


  inline unsigned int Size() const;

  void Reset();


  inline int GetNoPages() const;

  inline unsigned int GetPageSize() const;

  inline void GrowPageSize(unsigned int factor);


 private:
  struct G4PoolLink
  {
    G4PoolLink* next;
  };
  class G4PoolChunk
  {
   public:
    explicit G4PoolChunk(unsigned int sz)
      : size(sz)
      , mem(new char[size])
      , next(nullptr)
    {
      ;
    }
    ~G4PoolChunk() { delete[] mem; }
    const unsigned int size;
    char* mem;
    G4PoolChunk* next;
  };

  void Grow();


 private:
  const unsigned int esize;
  unsigned int csize;
  G4PoolChunk* chunks = nullptr;
  G4PoolLink* head = nullptr;
  int nchunks = 0;
};
# 114 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AllocatorPool.hh" 3
inline void* G4AllocatorPool::Alloc()
{
  if(head == nullptr)
  {
    Grow();
  }
  G4PoolLink* p = head;
  head = p->next;
  return p;
}





inline void G4AllocatorPool::Free(void* b)
{
  auto* p = static_cast<G4PoolLink*>(b);
  p->next = head;
  head = p;
}





inline unsigned int G4AllocatorPool::Size() const { return nchunks * csize; }





inline int G4AllocatorPool::GetNoPages() const { return nchunks; }





inline unsigned int G4AllocatorPool::GetPageSize() const { return csize; }





inline void G4AllocatorPool::GrowPageSize(unsigned int sz)
{
  csize = (sz) != 0u ? sz * csize : csize;
}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Allocator.hh" 2 3

class G4AllocatorBase
{
 public:
  G4AllocatorBase();
  virtual ~G4AllocatorBase() = default;
  virtual void ResetStorage() = 0;
  virtual std::size_t GetAllocatedSize() const = 0;
  virtual int GetNoPages() const = 0;
  virtual std::size_t GetPageSize() const = 0;
  virtual void IncreasePageSize(unsigned int sz) = 0;
  virtual const char* GetPoolType() const = 0;
};

template <class Type>
class G4Allocator : public G4AllocatorBase
{
 public:
  G4Allocator() throw();
  ~G4Allocator() throw() override;


  inline Type* MallocSingle();
  inline void FreeSingle(Type* anElement);



  inline void ResetStorage() override;



  inline std::size_t GetAllocatedSize() const override;

  inline int GetNoPages() const override;

  inline std::size_t GetPageSize() const override;

  inline void IncreasePageSize(unsigned int sz) override;


  inline const char* GetPoolType() const override;
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Allocator.hh" 3
  using value_type = Type;
  using size_type = std::size_t;
  using difference_type = ptrdiff_t;
  using pointer = Type*;
  using const_pointer = const Type*;
  using reference = Type&;
  using const_reference = const Type&;

  template <class U>
  G4Allocator(const G4Allocator<U>& right) throw()
    : mem(right.mem)
  {}


  pointer address(reference r) const { return &r; }
  const_pointer address(const_reference r) const { return &r; }


  pointer allocate(size_type n, void* = nullptr)
  {


    Type* mem_alloc = 0;
    if(n == 1)
      mem_alloc = MallocSingle();
    else
      mem_alloc = static_cast<Type*>(::operator new(n * sizeof(Type)));
    return mem_alloc;
  }
  void deallocate(pointer p, size_type n)
  {


    if(n == 1)
      FreeSingle(p);
    else
      ::operator delete((void*) p);
    return;
  }

  void construct(pointer p, const Type& val) { new((void*) p) Type(val); }

  void destroy(pointer p) { p->~Type(); }


  size_type max_size() const throw()
  {


    return 2147483647 / sizeof(Type);
  }

  template <class U>
  struct rebind
  {
    using other = G4Allocator<U>;
  };


  G4AllocatorPool mem;


 private:
  const char* tname;

};
# 176 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Allocator.hh" 3
template <class Type>
G4Allocator<Type>::G4Allocator() throw()
  : mem(sizeof(Type))
{
  tname = typeid(Type).name();
}





template <class Type>
G4Allocator<Type>::~G4Allocator() throw() = default;





template <class Type>
Type* G4Allocator<Type>::MallocSingle()
{
  return static_cast<Type*>(mem.Alloc());
}





template <class Type>
void G4Allocator<Type>::FreeSingle(Type* anElement)
{
  mem.Free(anElement);
  return;
}





template <class Type>
void G4Allocator<Type>::ResetStorage()
{


  mem.Reset();
  return;
}





template <class Type>
std::size_t G4Allocator<Type>::GetAllocatedSize() const
{
  return mem.Size();
}





template <class Type>
int G4Allocator<Type>::GetNoPages() const
{
  return mem.GetNoPages();
}





template <class Type>
size_t G4Allocator<Type>::GetPageSize() const
{
  return mem.GetPageSize();
}





template <class Type>
void G4Allocator<Type>::IncreasePageSize(unsigned int sz)
{
  ResetStorage();
  mem.GrowPageSize(sz);
}





template <class Type>
const char* G4Allocator<Type>::GetPoolType() const
{
  return tname;
}





template <class T1, class T2>
bool operator==(const G4Allocator<T1>&, const G4Allocator<T2>&) throw()
{
  return true;
}





template <class T1, class T2>
bool operator!=(const G4Allocator<T1>&, const G4Allocator<T2>&) throw()
{
  return false;
}
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4HCofThisEvent.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHitsCollection.hh" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHitsCollection.hh" 3
class G4VHit;
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHitsCollection.hh" 3
class G4VHitsCollection
{
 public:
  G4VHitsCollection() = default;
  G4VHitsCollection(G4String detName, G4String colNam);
  virtual ~G4VHitsCollection() = default;
  G4bool operator==(const G4VHitsCollection& right) const;

  virtual void DrawAllHits(){};
  virtual void PrintAllHits(){};

  inline const G4String& GetName() const { return collectionName; }
  inline const G4String& GetSDname() const { return SDname; }
  inline void SetColID(G4int i) { colID = i; }
  inline G4int GetColID() const { return colID; }




  virtual G4VHit* GetHit(size_t) const { return nullptr; }
  virtual size_t GetSize() const { return 0; };

 protected:

  G4String collectionName = "Unknown";
  G4String SDname = "Unknown";

  G4int colID = -1;
};
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4HCofThisEvent.hh" 2 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4HCofThisEvent.hh" 3
class G4HCofThisEvent
{
 public:
  G4HCofThisEvent();
  explicit G4HCofThisEvent(G4int cap);
  ~G4HCofThisEvent();
  G4HCofThisEvent(const G4HCofThisEvent&);
  G4HCofThisEvent& operator=(const G4HCofThisEvent&);

  inline void* operator new(size_t);
  inline void operator delete(void* anHCoTE);

  void AddHitsCollection(G4int HCID, G4VHitsCollection* aHC);






  inline G4VHitsCollection* GetHC(G4int i) { return (*HC)[i]; }



  inline G4int GetNumberOfCollections()
  {
    G4int n = 0;
    for (const G4VHitsCollection* h : *HC) {
      if (h != nullptr) n++;
    }
    return n;
  }

  inline size_t GetCapacity() { return HC->size(); }

 private:
  std::vector<G4VHitsCollection*>* HC;
};




extern G4Allocator<G4HCofThisEvent>*& anHCoTHAllocator_G4MT_TLS_();


inline void* G4HCofThisEvent::operator new(size_t)
{
  if (anHCoTHAllocator_G4MT_TLS_() == nullptr) {
    anHCoTHAllocator_G4MT_TLS_() = new G4Allocator<G4HCofThisEvent>;
  }
  return (void*)anHCoTHAllocator_G4MT_TLS_()->MallocSingle();
}

inline void G4HCofThisEvent::operator delete(void* anHCoTH)
{
  anHCoTHAllocator_G4MT_TLS_()->FreeSingle((G4HCofThisEvent*)anHCoTH);
}
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ThreeVector.hh" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ThreeVector.hh" 3
using G4ThreeVector = CLHEP::Hep3Vector;
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/geomdefs.hh" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/geomdefs.hh" 3
static const G4double kInfinity = 9.0E99;



static const double kMinExitingNormalCosine = 1E-3;







enum EAxis
{
  kXAxis,
  kYAxis,
  kZAxis,
  kRho,
  kRadial3D,
  kPhi,
  kUndefined
};



enum EInside
{
  kOutside,
  kSurface,
  kInside
};
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/geomdefs.hh" 3
enum EVolume
{
  kNormal,
  kReplica,
  kParameterised,
  kExternal
};



static const G4int kHistoryMax = 15;



static const G4int kHistoryStride = 16;



static const G4int kNavigatorVoxelStackMax = 3;
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4RotationMatrix.hh" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4RotationMatrix.hh" 3
using G4RotationMatrix = CLHEP::HepRotation;
using G4Rep3x3 = CLHEP::HepRep3x3;
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4GeomSplitter.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4GeomSplitter.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/geomwdefs.hh" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4GeomSplitter.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 1 3
# 262 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 1 3
# 61 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
  namespace chrono
  {



    struct local_t { };
    template<typename _Duration>
      using local_time = time_point<local_t, _Duration>;
    using local_seconds = local_time<seconds>;
    using local_days = local_time<days>;


    class utc_clock;
    class tai_clock;
    class gps_clock;

    template<typename _Duration>
      using utc_time = time_point<utc_clock, _Duration>;
    using utc_seconds = utc_time<seconds>;

    template<typename _Duration>
      using tai_time = time_point<tai_clock, _Duration>;
    using tai_seconds = tai_time<seconds>;

    template<typename _Duration>
      using gps_time = time_point<gps_clock, _Duration>;
    using gps_seconds = gps_time<seconds>;

    template<> struct is_clock<utc_clock> : true_type { };
    template<> struct is_clock<tai_clock> : true_type { };
    template<> struct is_clock<gps_clock> : true_type { };

    template<> inline constexpr bool is_clock_v<utc_clock> = true;
    template<> inline constexpr bool is_clock_v<tai_clock> = true;
    template<> inline constexpr bool is_clock_v<gps_clock> = true;

    struct leap_second_info
    {
      bool is_leap_second;
      seconds elapsed;
    };

    template<typename _Duration>
      leap_second_info
      get_leap_second_info(const utc_time<_Duration>& __ut);







    class utc_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<utc_clock>;
      static constexpr bool is_steady = false;

      [[nodiscard]]
      static time_point
      now()
      { return from_sys(system_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static sys_time<common_type_t<_Duration, seconds>>
 to_sys(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   const auto __li = chrono::get_leap_second_info(__t);
   sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
   if (__li.is_leap_second)
     __s = chrono::floor<seconds>(__s) + seconds{1} - _CDur{1};
   return __s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 from_sys(const sys_time<_Duration>& __t);
    };







    class tai_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<tai_clock>;
      static constexpr bool is_steady = false;


      [[nodiscard]]
      static time_point
      now()
      { return from_utc(utc_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 to_utc(const tai_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return utc_time<_CDur>{__t.time_since_epoch()} - 378691210s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static tai_time<common_type_t<_Duration, seconds>>
 from_utc(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return tai_time<_CDur>{__t.time_since_epoch()} + 378691210s;
 }
    };







    class gps_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<gps_clock>;
      static constexpr bool is_steady = false;


      [[nodiscard]]
      static time_point
      now()
      { return from_utc(utc_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 to_utc(const gps_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return utc_time<_CDur>{__t.time_since_epoch()} + 315964809s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static gps_time<common_type_t<_Duration, seconds>>
 from_utc(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return gps_time<_CDur>{__t.time_since_epoch()} - 315964809s;
 }
    };


    template<typename _DestClock, typename _SourceClock>
      struct clock_time_conversion
      { };



    template<typename _Clock>
      struct clock_time_conversion<_Clock, _Clock>
      {
 template<typename _Duration>
   time_point<_Clock, _Duration>
   operator()(const time_point<_Clock, _Duration>& __t) const
   { return __t; }
      };


    template<>
      struct clock_time_conversion<system_clock, system_clock>
      {
 template<typename _Duration>
   sys_time<_Duration>
   operator()(const sys_time<_Duration>& __t) const
   { return __t; }
      };

    template<>
      struct clock_time_conversion<utc_clock, utc_clock>
      {
 template<typename _Duration>
   utc_time<_Duration>
   operator()(const utc_time<_Duration>& __t) const
   { return __t; }
      };



    template<>
      struct clock_time_conversion<utc_clock, system_clock>
      {
 template<typename _Duration>
   utc_time<common_type_t<_Duration, seconds>>
   operator()(const sys_time<_Duration>& __t) const
   { return utc_clock::from_sys(__t); }
      };

    template<>
      struct clock_time_conversion<system_clock, utc_clock>
      {
 template<typename _Duration>
   sys_time<common_type_t<_Duration, seconds>>
   operator()(const utc_time<_Duration>& __t) const
   { return utc_clock::to_sys(__t); }
      };

    template<typename _Tp, typename _Clock>
      inline constexpr bool __is_time_point_for_v = false;

    template<typename _Clock, typename _Duration>
      inline constexpr bool
       __is_time_point_for_v<time_point<_Clock, _Duration>, _Clock> = true;



    template<typename _SourceClock>
      struct clock_time_conversion<system_clock, _SourceClock>
      {
 template<typename _Duration, typename _Src = _SourceClock>
   auto
   operator()(const time_point<_SourceClock, _Duration>& __t) const
   -> decltype(_Src::to_sys(__t))
   {
     using _Ret = decltype(_SourceClock::to_sys(__t));
     static_assert(__is_time_point_for_v<_Ret, system_clock>);
     return _SourceClock::to_sys(__t);
   }
      };

    template<typename _DestClock>
      struct clock_time_conversion<_DestClock, system_clock>
      {
 template<typename _Duration, typename _Dest = _DestClock>
   auto
   operator()(const sys_time<_Duration>& __t) const
   -> decltype(_Dest::from_sys(__t))
   {
     using _Ret = decltype(_DestClock::from_sys(__t));
     static_assert(__is_time_point_for_v<_Ret, _DestClock>);
     return _DestClock::from_sys(__t);
   }
      };



    template<typename _SourceClock>
      struct clock_time_conversion<utc_clock, _SourceClock>
      {
 template<typename _Duration, typename _Src = _SourceClock>
   auto
   operator()(const time_point<_SourceClock, _Duration>& __t) const
   -> decltype(_Src::to_utc(__t))
   {
     using _Ret = decltype(_SourceClock::to_utc(__t));
     static_assert(__is_time_point_for_v<_Ret, utc_clock>);
     return _SourceClock::to_utc(__t);
   }
      };

    template<typename _DestClock>
      struct clock_time_conversion<_DestClock, utc_clock>
      {
 template<typename _Duration, typename _Dest = _DestClock>
   auto
   operator()(const utc_time<_Duration>& __t) const
   -> decltype(_Dest::from_utc(__t))
   {
     using _Ret = decltype(_DestClock::from_utc(__t));
     static_assert(__is_time_point_for_v<_Ret, _DestClock>);
     return _DestClock::from_utc(__t);
   }
      };



    namespace __detail
    {
      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, _SourceClock>{}(__t);
   };


      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_sys
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, _SourceClock>{}(__t));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_utc
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, _SourceClock>{}(__t));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
 concept __clock_convs_sys_utc
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, system_clock>{}(
  clock_time_conversion<system_clock, _SourceClock>{}(__t)));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_utc_sys
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, utc_clock>{}(
  clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
   };

    }



    template<typename _DestClock, typename _SourceClock, typename _Duration>
      [[nodiscard]]
      inline auto
      clock_cast(const time_point<_SourceClock, _Duration>& __t)
      requires __detail::__clock_convs<_DestClock, _SourceClock, _Duration>

 || __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_sys_utc<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_utc_sys<_DestClock, _SourceClock, _Duration>

      {
       constexpr bool __direct
  = __detail::__clock_convs<_DestClock, _SourceClock, _Duration>;
       if constexpr (__direct)
  {
    return clock_time_conversion<_DestClock, _SourceClock>{}(__t);
  }

       else
  {
    constexpr bool __convert_via_sys_clock
      = __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>;
    constexpr bool __convert_via_utc_clock
      = __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>;
    if constexpr (__convert_via_sys_clock)
      {
        static_assert(!__convert_via_utc_clock,
   "clock_cast requires a unique best conversion, but "
   "conversion is possible via system_clock and also via"
   "utc_clock");
        return clock_time_conversion<_DestClock, system_clock>{}(
   clock_time_conversion<system_clock, _SourceClock>{}(__t));
      }
    else if constexpr (__convert_via_utc_clock)
      {
        return clock_time_conversion<_DestClock, utc_clock>{}(
   clock_time_conversion<utc_clock, _SourceClock>{}(__t));
      }
    else
      {
        constexpr bool __convert_via_sys_and_utc_clocks
   = __detail::__clock_convs_sys_utc<_DestClock,
         _SourceClock,
         _Duration>;

        if constexpr (__convert_via_sys_and_utc_clocks)
   {
     constexpr bool __convert_via_utc_and_sys_clocks
       = __detail::__clock_convs_utc_sys<_DestClock,
             _SourceClock,
             _Duration>;
     static_assert(!__convert_via_utc_and_sys_clocks,
       "clock_cast requires a unique best conversion, but "
       "conversion is possible via system_clock followed by "
       "utc_clock, and also via utc_clock followed by "
       "system_clock");
     return clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, system_clock>{}(
         clock_time_conversion<system_clock, _SourceClock>{}(__t)));
   }
        else
   {
     return clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, utc_clock>{}(
         clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
   }
      }
  }

      }




    class day;
    class month;
    class year;
    class weekday;
    class weekday_indexed;
    class weekday_last;
    class month_day;
    class month_day_last;
    class month_weekday;
    class month_weekday_last;
    class year_month;
    class year_month_day;
    class year_month_day_last;
    class year_month_weekday;
    class year_month_weekday_last;

    struct last_spec
    {
      explicit last_spec() = default;

      friend constexpr month_day_last
      operator/(int __m, last_spec) noexcept;

      friend constexpr month_day_last
      operator/(last_spec, int __m) noexcept;
    };

    inline constexpr last_spec last{};

    namespace __detail
    {

      template <unsigned __d, typename _Tp>
      consteval auto
      __modulo_offset()
      {
 using _Up = make_unsigned_t<_Tp>;
 auto constexpr __a = _Up(-1) - _Up(255 + __d - 2);
 auto constexpr __b = _Up(__d * (__a / __d) - 1);

 return _Up(-1) - __b;
      }




      template <unsigned __d, typename _Tp>
      constexpr unsigned
      __add_modulo(unsigned __x, _Tp __y)
      {
 using _Up = make_unsigned_t<_Tp>;
# 547 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
 auto const __offset = __y >= 0 ? _Up(0) : __modulo_offset<__d, _Tp>();
 return (__x + _Up(__y) - __offset) % __d;
      }


      template <unsigned __d, typename _Tp>
      constexpr unsigned
      __sub_modulo(unsigned __x, _Tp __y)
      {
 using _Up = make_unsigned_t<_Tp>;
 auto const __offset = __y <= 0 ? _Up(0) : __modulo_offset<__d, _Tp>();
 return (__x - _Up(__y) - __offset) % __d;
      }

      inline constexpr unsigned __days_per_month[12]
 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    }



    class day
    {
    private:
      unsigned char _M_d;

    public:
      day() = default;

      explicit constexpr
      day(unsigned __d) noexcept
      : _M_d(__d)
      { }

      constexpr day&
      operator++() noexcept
      {
 ++_M_d;
 return *this;
      }

      constexpr day
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr day&
      operator--() noexcept
      {
 --_M_d;
 return *this;
      }

      constexpr day
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr day&
      operator+=(const days& __d) noexcept
      {
 *this = *this + __d;
 return *this;
      }

      constexpr day&
      operator-=(const days& __d) noexcept
      {
 *this = *this - __d;
 return *this;
      }

      constexpr explicit
      operator unsigned() const noexcept
      { return _M_d; }

      constexpr bool
      ok() const noexcept
      { return 1 <= _M_d && _M_d <= 31; }

      friend constexpr bool
      operator==(const day& __x, const day& __y) noexcept
      { return unsigned{__x} == unsigned{__y}; }

      friend constexpr strong_ordering
      operator<=>(const day& __x, const day& __y) noexcept
      { return unsigned{__x} <=> unsigned{__y}; }

      friend constexpr day
      operator+(const day& __x, const days& __y) noexcept
      { return day(unsigned{__x} + __y.count()); }

      friend constexpr day
      operator+(const days& __x, const day& __y) noexcept
      { return __y + __x; }

      friend constexpr day
      operator-(const day& __x, const days& __y) noexcept
      { return __x + -__y; }

      friend constexpr days
      operator-(const day& __x, const day& __y) noexcept
      { return days{int(unsigned{__x}) - int(unsigned{__y})}; }

      friend constexpr month_day
      operator/(const month& __m, const day& __d) noexcept;

      friend constexpr month_day
      operator/(int __m, const day& __d) noexcept;

      friend constexpr month_day
      operator/(const day& __d, const month& __m) noexcept;

      friend constexpr month_day
      operator/(const day& __d, int __m) noexcept;

      friend constexpr year_month_day
      operator/(const year_month& __ym, const day& __d) noexcept;
    };



    class month
    {
    private:
      unsigned char _M_m;

    public:
      month() = default;

      explicit constexpr
      month(unsigned __m) noexcept
      : _M_m(__m)
      { }

      constexpr month&
      operator++() noexcept
      {
 *this += months{1};
 return *this;
      }

      constexpr month
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr month&
      operator--() noexcept
      {
 *this -= months{1};
 return *this;
      }

      constexpr month
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr month&
      operator+=(const months& __m) noexcept
      {
 *this = *this + __m;
 return *this;
      }

      constexpr month&
      operator-=(const months& __m) noexcept
      {
 *this = *this - __m;
 return *this;
      }

      explicit constexpr
      operator unsigned() const noexcept
      { return _M_m; }

      constexpr bool
      ok() const noexcept
      { return 1 <= _M_m && _M_m <= 12; }

      friend constexpr bool
      operator==(const month& __x, const month& __y) noexcept
      { return unsigned{__x} == unsigned{__y}; }

      friend constexpr strong_ordering
      operator<=>(const month& __x, const month& __y) noexcept
      { return unsigned{__x} <=> unsigned{__y}; }

      friend constexpr month
      operator+(const month& __x, const months& __y) noexcept
      {


 return month{1 + __detail::__add_modulo<12>(
   unsigned{__x} + 11, __y.count())};
      }

      friend constexpr month
      operator+(const months& __x, const month& __y) noexcept
      { return __y + __x; }

      friend constexpr month
      operator-(const month& __x, const months& __y) noexcept
      {


 return month{1 + __detail::__sub_modulo<12>(
   unsigned{__x} + 11, __y.count())};
      }

      friend constexpr months
      operator-(const month& __x, const month& __y) noexcept
      {
 const auto __dm = int(unsigned(__x)) - int(unsigned(__y));
 return months{__dm < 0 ? 12 + __dm : __dm};
      }

      friend constexpr year_month
      operator/(const year& __y, const month& __m) noexcept;

      friend constexpr month_day
      operator/(const month& __m, int __d) noexcept;

      friend constexpr month_day_last
      operator/(const month& __m, last_spec) noexcept;

      friend constexpr month_day_last
      operator/(last_spec, const month& __m) noexcept;

      friend constexpr month_weekday
      operator/(const month& __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, const month& __m) noexcept;

      friend constexpr month_weekday_last
      operator/(const month& __m, const weekday_last& __wdl) noexcept;

      friend constexpr month_weekday_last
      operator/(const weekday_last& __wdl, const month& __m) noexcept;
    };

    inline constexpr month January{1};
    inline constexpr month February{2};
    inline constexpr month March{3};
    inline constexpr month April{4};
    inline constexpr month May{5};
    inline constexpr month June{6};
    inline constexpr month July{7};
    inline constexpr month August{8};
    inline constexpr month September{9};
    inline constexpr month October{10};
    inline constexpr month November{11};
    inline constexpr month December{12};



    class year
    {
    private:
      short _M_y;

    public:
      year() = default;

      explicit constexpr
      year(int __y) noexcept
      : _M_y{static_cast<short>(__y)}
      { }

      static constexpr year
      min() noexcept
      { return year{-32767}; }

      static constexpr year
      max() noexcept
      { return year{32767}; }

      constexpr year&
      operator++() noexcept
      {
 ++_M_y;
 return *this;
      }

      constexpr year
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr year&
      operator--() noexcept
      {
 --_M_y;
 return *this;
      }

      constexpr year
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr year&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr year
      operator+() const noexcept
      { return *this; }

      constexpr year
      operator-() const noexcept
      { return year{-_M_y}; }

      constexpr bool
      is_leap() const noexcept
      {
# 914 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
 return (_M_y & (_M_y % 25 == 0 ? 15 : 3)) == 0;
      }

      explicit constexpr
      operator int() const noexcept
      { return _M_y; }

      constexpr bool
      ok() const noexcept
      { return min()._M_y <= _M_y && _M_y <= max()._M_y; }

      friend constexpr bool
      operator==(const year& __x, const year& __y) noexcept
      { return int{__x} == int{__y}; }

      friend constexpr strong_ordering
      operator<=>(const year& __x, const year& __y) noexcept
      { return int{__x} <=> int{__y}; }

      friend constexpr year
      operator+(const year& __x, const years& __y) noexcept
      { return year{int{__x} + static_cast<int>(__y.count())}; }

      friend constexpr year
      operator+(const years& __x, const year& __y) noexcept
      { return __y + __x; }

      friend constexpr year
      operator-(const year& __x, const years& __y) noexcept
      { return __x + -__y; }

      friend constexpr years
      operator-(const year& __x, const year& __y) noexcept
      { return years{int{__x} - int{__y}}; }

      friend constexpr year_month
      operator/(const year& __y, int __m) noexcept;

      friend constexpr year_month_day
      operator/(const year& __y, const month_day& __md) noexcept;

      friend constexpr year_month_day
      operator/(const month_day& __md, const year& __y) noexcept;

      friend constexpr year_month_day_last
      operator/(const year& __y, const month_day_last& __mdl) noexcept;

      friend constexpr year_month_day_last
      operator/(const month_day_last& __mdl, const year& __y) noexcept;

      friend constexpr year_month_weekday
      operator/(const year& __y, const month_weekday& __mwd) noexcept;

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, const year& __y) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const year& __y, const month_weekday_last& __mwdl) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const month_weekday_last& __mwdl, const year& __y) noexcept;
    };



    class weekday
    {
    private:
      unsigned char _M_wd;

      static constexpr weekday
      _S_from_days(const days& __d)
      {
 return weekday{__detail::__add_modulo<7>(4, __d.count())};
      }

    public:
      weekday() = default;

      explicit constexpr
      weekday(unsigned __wd) noexcept
      : _M_wd(__wd == 7 ? 0 : __wd)
      { }

      constexpr
      weekday(const sys_days& __dp) noexcept
      : weekday{_S_from_days(__dp.time_since_epoch())}
      { }

      explicit constexpr
      weekday(const local_days& __dp) noexcept
      : weekday{sys_days{__dp.time_since_epoch()}}
      { }

      constexpr weekday&
      operator++() noexcept
      {
 *this += days{1};
 return *this;
      }

      constexpr weekday
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr weekday&
      operator--() noexcept
      {
 *this -= days{1};
 return *this;
      }

      constexpr weekday
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr weekday&
      operator+=(const days& __d) noexcept
      {
 *this = *this + __d;
 return *this;
      }

      constexpr weekday&
      operator-=(const days& __d) noexcept
      {
 *this = *this - __d;
 return *this;
      }

      constexpr unsigned
      c_encoding() const noexcept
      { return _M_wd; }

      constexpr unsigned
      iso_encoding() const noexcept
      { return _M_wd == 0u ? 7u : _M_wd; }

      constexpr bool
      ok() const noexcept
      { return _M_wd <= 6; }

      constexpr weekday_indexed
      operator[](unsigned __index) const noexcept;

      constexpr weekday_last
      operator[](last_spec) const noexcept;

      friend constexpr bool
      operator==(const weekday& __x, const weekday& __y) noexcept
      { return __x._M_wd == __y._M_wd; }

      friend constexpr weekday
      operator+(const weekday& __x, const days& __y) noexcept
      {
 return weekday{__detail::__add_modulo<7>(__x._M_wd, __y.count())};
      }

      friend constexpr weekday
      operator+(const days& __x, const weekday& __y) noexcept
      { return __y + __x; }

      friend constexpr weekday
      operator-(const weekday& __x, const days& __y) noexcept
      {
 return weekday{__detail::__sub_modulo<7>(__x._M_wd, __y.count())};
      }

      friend constexpr days
      operator-(const weekday& __x, const weekday& __y) noexcept
      {
 const auto __n = __x.c_encoding() - __y.c_encoding();
 return static_cast<int>(__n) >= 0 ? days{__n} : days{__n + 7};
      }
    };

    inline constexpr weekday Sunday{0};
    inline constexpr weekday Monday{1};
    inline constexpr weekday Tuesday{2};
    inline constexpr weekday Wednesday{3};
    inline constexpr weekday Thursday{4};
    inline constexpr weekday Friday{5};
    inline constexpr weekday Saturday{6};



    class weekday_indexed
    {
    private:
      chrono::weekday _M_wd;
      unsigned char _M_index;

    public:
      weekday_indexed() = default;

      constexpr
      weekday_indexed(const chrono::weekday& __wd, unsigned __index) noexcept
      : _M_wd(__wd), _M_index(__index)
      { }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wd; }

      constexpr unsigned
      index() const noexcept
      { return _M_index; };

      constexpr bool
      ok() const noexcept
      { return _M_wd.ok() && 1 <= _M_index && _M_index <= 5; }

      friend constexpr bool
      operator==(const weekday_indexed& __x, const weekday_indexed& __y) noexcept
      { return __x.weekday() == __y.weekday() && __x.index() == __y.index(); }

      friend constexpr month_weekday
      operator/(const month& __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(int __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, const month& __m) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, int __m) noexcept;

      friend constexpr year_month_weekday
      operator/(const year_month& __ym, const weekday_indexed& __wdi) noexcept;
    };

    constexpr weekday_indexed
    weekday::operator[](unsigned __index) const noexcept
    { return {*this, __index}; }



    class weekday_last
    {
    private:
      chrono::weekday _M_wd;

    public:
      explicit constexpr
      weekday_last(const chrono::weekday& __wd) noexcept
      : _M_wd{__wd}
      { }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wd; }

      constexpr bool
      ok() const noexcept
      { return _M_wd.ok(); }

      friend constexpr bool
      operator==(const weekday_last& __x, const weekday_last& __y) noexcept
      { return __x.weekday() == __y.weekday(); }

      friend constexpr month_weekday_last
      operator/(int __m, const weekday_last& __wdl) noexcept;

      friend constexpr month_weekday_last
      operator/(const weekday_last& __wdl, int __m) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const year_month& __ym, const weekday_last& __wdl) noexcept;
    };

    constexpr weekday_last
    weekday::operator[](last_spec) const noexcept
    { return weekday_last{*this}; }



    class month_day
    {
    private:
      chrono::month _M_m;
      chrono::day _M_d;

    public:
      month_day() = default;

      constexpr
      month_day(const chrono::month& __m, const chrono::day& __d) noexcept
      : _M_m{__m}, _M_d{__d}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::day
      day() const noexcept
      { return _M_d; }

      constexpr bool
      ok() const noexcept
      {
 return _M_m.ok()
   && 1u <= unsigned(_M_d)
   && unsigned(_M_d) <= __detail::__days_per_month[unsigned(_M_m) - 1];
      }

      friend constexpr bool
      operator==(const month_day& __x, const month_day& __y) noexcept
      { return __x.month() == __y.month() && __x.day() == __y.day(); }

      friend constexpr strong_ordering
      operator<=>(const month_day& __x, const month_day& __y) noexcept
 = default;

      friend constexpr month_day
      operator/(const chrono::month& __m, const chrono::day& __d) noexcept
      { return {__m, __d}; }

      friend constexpr month_day
      operator/(const chrono::month& __m, int __d) noexcept
      { return {__m, chrono::day(unsigned(__d))}; }

      friend constexpr month_day
      operator/(int __m, const chrono::day& __d) noexcept
      { return {chrono::month(unsigned(__m)), __d}; }

      friend constexpr month_day
      operator/(const chrono::day& __d, const chrono::month& __m) noexcept
      { return {__m, __d}; }

      friend constexpr month_day
      operator/(const chrono::day& __d, int __m) noexcept
      { return {chrono::month(unsigned(__m)), __d}; }

      friend constexpr year_month_day
      operator/(int __y, const month_day& __md) noexcept;

      friend constexpr year_month_day
      operator/(const month_day& __md, int __y) noexcept;
    };



    class month_day_last
    {
    private:
      chrono::month _M_m;

    public:
      explicit constexpr
      month_day_last(const chrono::month& __m) noexcept
      : _M_m{__m}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok(); }

      friend constexpr bool
      operator==(const month_day_last& __x, const month_day_last& __y) noexcept
      { return __x.month() == __y.month(); }

      friend constexpr strong_ordering
      operator<=>(const month_day_last& __x, const month_day_last& __y) noexcept
 = default;

      friend constexpr month_day_last
      operator/(const chrono::month& __m, last_spec) noexcept
      { return month_day_last{__m}; }

      friend constexpr month_day_last
      operator/(int __m, last_spec) noexcept
      { return chrono::month(unsigned(__m)) / last; }

      friend constexpr month_day_last
      operator/(last_spec, const chrono::month& __m) noexcept
      { return __m / last; }

      friend constexpr month_day_last
      operator/(last_spec, int __m) noexcept
      { return __m / last; }

      friend constexpr year_month_day_last
      operator/(int __y, const month_day_last& __mdl) noexcept;

      friend constexpr year_month_day_last
      operator/(const month_day_last& __mdl, int __y) noexcept;
    };



    class month_weekday
    {
    private:
      chrono::month _M_m;
      chrono::weekday_indexed _M_wdi;

    public:
      constexpr
      month_weekday(const chrono::month& __m,
      const chrono::weekday_indexed& __wdi) noexcept
      : _M_m{__m}, _M_wdi{__wdi}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday_indexed
      weekday_indexed() const noexcept
      { return _M_wdi; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok() && _M_wdi.ok(); }

      friend constexpr bool
      operator==(const month_weekday& __x, const month_weekday& __y) noexcept
      {
 return __x.month() == __y.month()
   && __x.weekday_indexed() == __y.weekday_indexed();
      }

      friend constexpr month_weekday
      operator/(const chrono::month& __m,
  const chrono::weekday_indexed& __wdi) noexcept
      { return {__m, __wdi}; }

      friend constexpr month_weekday
      operator/(int __m, const chrono::weekday_indexed& __wdi) noexcept
      { return chrono::month(unsigned(__m)) / __wdi; }

      friend constexpr month_weekday
      operator/(const chrono::weekday_indexed& __wdi,
  const chrono::month& __m) noexcept
      { return __m / __wdi; }

      friend constexpr month_weekday
      operator/(const chrono::weekday_indexed& __wdi, int __m) noexcept
      { return __m / __wdi; }

      friend constexpr year_month_weekday
      operator/(int __y, const month_weekday& __mwd) noexcept;

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, int __y) noexcept;
    };



    class month_weekday_last
    {
    private:
      chrono::month _M_m;
      chrono::weekday_last _M_wdl;

    public:
      constexpr
      month_weekday_last(const chrono::month& __m,
    const chrono::weekday_last& __wdl) noexcept
      :_M_m{__m}, _M_wdl{__wdl}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday_last
      weekday_last() const noexcept
      { return _M_wdl; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok() && _M_wdl.ok(); }

      friend constexpr bool
      operator==(const month_weekday_last& __x,
   const month_weekday_last& __y) noexcept
      {
 return __x.month() == __y.month()
   && __x.weekday_last() == __y.weekday_last();
      }

      friend constexpr month_weekday_last
      operator/(const chrono::month& __m,
  const chrono::weekday_last& __wdl) noexcept
      { return {__m, __wdl}; }

      friend constexpr month_weekday_last
      operator/(int __m, const chrono::weekday_last& __wdl) noexcept
      { return chrono::month(unsigned(__m)) / __wdl; }

      friend constexpr month_weekday_last
      operator/(const chrono::weekday_last& __wdl,
  const chrono::month& __m) noexcept
      { return __m / __wdl; }

      friend constexpr month_weekday_last
      operator/(const chrono::weekday_last& __wdl, int __m) noexcept
      { return chrono::month(unsigned(__m)) / __wdl; }

      friend constexpr year_month_weekday_last
      operator/(int __y, const month_weekday_last& __mwdl) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const month_weekday_last& __mwdl, int __y) noexcept;
    };



    namespace __detail
    {
# 1451 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
      using __months_years_conversion_disambiguator = void;
    }

    class year_month
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;

    public:
      year_month() = default;

      constexpr
      year_month(const chrono::year& __y, const chrono::month& __m) noexcept
      : _M_y{__y}, _M_m{__m}
      { }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month&
 operator+=(const months& __dm) noexcept
 {
   *this = *this + __dm;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month&
 operator-=(const months& __dm) noexcept
 {
   *this = *this - __dm;
   return *this;
 }

      constexpr year_month&
      operator+=(const years& __dy) noexcept
      {
 *this = *this + __dy;
 return *this;
      }

      constexpr year_month&
      operator-=(const years& __dy) noexcept
      {
 *this = *this - __dy;
 return *this;
      }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_m.ok(); }

      friend constexpr bool
      operator==(const year_month& __x, const year_month& __y) noexcept
      { return __x.year() == __y.year() && __x.month() == __y.month(); }

      friend constexpr strong_ordering
      operator<=>(const year_month& __x, const year_month& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator+(const year_month& __ym, const months& __dm) noexcept
 {

   auto __m = __ym.month() + __dm;
   auto __i = int(unsigned(__ym.month())) - 1 + __dm.count();
   auto __y = (__i < 0
        ? __ym.year() + years{(__i - 11) / 12}
        : __ym.year() + years{__i / 12});
   return __y / __m;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator+(const months& __dm, const year_month& __ym) noexcept
 { return __ym + __dm; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator-(const year_month& __ym, const months& __dm) noexcept
 { return __ym + -__dm; }

      friend constexpr months
      operator-(const year_month& __x, const year_month& __y) noexcept
      {
 return (__x.year() - __y.year()
  + months{static_cast<int>(unsigned{__x.month()})
    - static_cast<int>(unsigned{__y.month()})});
      }

      friend constexpr year_month
      operator+(const year_month& __ym, const years& __dy) noexcept
      { return (__ym.year() + __dy) / __ym.month(); }

      friend constexpr year_month
      operator+(const years& __dy, const year_month& __ym) noexcept
      { return __ym + __dy; }

      friend constexpr year_month
      operator-(const year_month& __ym, const years& __dy) noexcept
      { return __ym + -__dy; }

      friend constexpr year_month
      operator/(const chrono::year& __y, const chrono::month& __m) noexcept
      { return {__y, __m}; }

      friend constexpr year_month
      operator/(const chrono::year& __y, int __m) noexcept
      { return {__y, chrono::month(unsigned(__m))}; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, int __d) noexcept;

      friend constexpr year_month_day_last
      operator/(const year_month& __ym, last_spec) noexcept;
    };



    class year_month_day
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::day _M_d;

      static constexpr year_month_day _S_from_days(const days& __dp) noexcept;

      constexpr days _M_days_since_epoch() const noexcept;

    public:
      year_month_day() = default;

      constexpr
      year_month_day(const chrono::year& __y, const chrono::month& __m,
       const chrono::day& __d) noexcept
      : _M_y{__y}, _M_m{__m}, _M_d{__d}
      { }

      constexpr
      year_month_day(const year_month_day_last& __ymdl) noexcept;

      constexpr
      year_month_day(const sys_days& __dp) noexcept
      : year_month_day(_S_from_days(__dp.time_since_epoch()))
      { }

      explicit constexpr
      year_month_day(const local_days& __dp) noexcept
      : year_month_day(sys_days{__dp.time_since_epoch()})
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_day&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_day&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::day
      day() const noexcept
      { return _M_d; }

      constexpr
      operator sys_days() const noexcept
      { return sys_days{_M_days_since_epoch()}; }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool ok() const noexcept;

      friend constexpr bool
      operator==(const year_month_day& __x, const year_month_day& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.day() == __y.day();
      }

      friend constexpr strong_ordering
      operator<=>(const year_month_day& __x, const year_month_day& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator+(const year_month_day& __ymd, const months& __dm) noexcept
 { return (__ymd.year() / __ymd.month() + __dm) / __ymd.day(); }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator+(const months& __dm, const year_month_day& __ymd) noexcept
 { return __ymd + __dm; }

      friend constexpr year_month_day
      operator+(const year_month_day& __ymd, const years& __dy) noexcept
      { return (__ymd.year() + __dy) / __ymd.month() / __ymd.day(); }

      friend constexpr year_month_day
      operator+(const years& __dy, const year_month_day& __ymd) noexcept
      { return __ymd + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator-(const year_month_day& __ymd, const months& __dm) noexcept
 { return __ymd + -__dm; }

      friend constexpr year_month_day
      operator-(const year_month_day& __ymd, const years& __dy) noexcept
      { return __ymd + -__dy; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, const chrono::day& __d) noexcept
      { return {__ym.year(), __ym.month(), __d}; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, int __d) noexcept
      { return __ym / chrono::day{unsigned(__d)}; }

      friend constexpr year_month_day
      operator/(const chrono::year& __y, const month_day& __md) noexcept
      { return __y / __md.month() / __md.day(); }

      friend constexpr year_month_day
      operator/(int __y, const month_day& __md) noexcept
      { return chrono::year{__y} / __md; }

      friend constexpr year_month_day
      operator/(const month_day& __md, const chrono::year& __y) noexcept
      { return __y / __md; }

      friend constexpr year_month_day
      operator/(const month_day& __md, int __y) noexcept
      { return chrono::year(__y) / __md; }
    };





    constexpr year_month_day
    year_month_day::_S_from_days(const days& __dp) noexcept
    {
      constexpr auto __z2 = static_cast<uint32_t>(-1468000);
      constexpr auto __r2_e3 = static_cast<uint32_t>(536895458);

      const auto __r0 = static_cast<uint32_t>(__dp.count()) + __r2_e3;

      const auto __n1 = 4 * __r0 + 3;
      const auto __q1 = __n1 / 146097;
      const auto __r1 = __n1 % 146097 / 4;

      constexpr auto __p32 = static_cast<uint64_t>(1) << 32;
      const auto __n2 = 4 * __r1 + 3;
      const auto __u2 = static_cast<uint64_t>(2939745) * __n2;
      const auto __q2 = static_cast<uint32_t>(__u2 / __p32);
      const auto __r2 = static_cast<uint32_t>(__u2 % __p32) / 2939745 / 4;

      constexpr auto __p16 = static_cast<uint32_t>(1) << 16;
      const auto __n3 = 2141 * __r2 + 197913;
      const auto __q3 = __n3 / __p16;
      const auto __r3 = __n3 % __p16 / 2141;

      const auto __y0 = 100 * __q1 + __q2;
      const auto __m0 = __q3;
      const auto __d0 = __r3;

      const auto __j = __r2 >= 306;
      const auto __y1 = __y0 + __j;
      const auto __m1 = __j ? __m0 - 12 : __m0;
      const auto __d1 = __d0 + 1;

      return year_month_day{chrono::year{static_cast<int>(__y1 + __z2)},
       chrono::month{__m1}, chrono::day{__d1}};
    }





    constexpr days
    year_month_day::_M_days_since_epoch() const noexcept
    {
      auto constexpr __z2 = static_cast<uint32_t>(-1468000);
      auto constexpr __r2_e3 = static_cast<uint32_t>(536895458);

      const auto __y1 = static_cast<uint32_t>(static_cast<int>(_M_y)) - __z2;
      const auto __m1 = static_cast<uint32_t>(static_cast<unsigned>(_M_m));
      const auto __d1 = static_cast<uint32_t>(static_cast<unsigned>(_M_d));

      const auto __j = static_cast<uint32_t>(__m1 < 3);
      const auto __y0 = __y1 - __j;
      const auto __m0 = __j ? __m1 + 12 : __m1;
      const auto __d0 = __d1 - 1;

      const auto __q1 = __y0 / 100;
      const auto __yc = 1461 * __y0 / 4 - __q1 + __q1 / 4;
      const auto __mc = (979 *__m0 - 2919) / 32;
      const auto __dc = __d0;

      return days{static_cast<int32_t>(__yc + __mc + __dc - __r2_e3)};
    }



    class year_month_day_last
    {
    private:
      chrono::year _M_y;
      chrono::month_day_last _M_mdl;

    public:
      constexpr
      year_month_day_last(const chrono::year& __y,
     const chrono::month_day_last& __mdl) noexcept
      : _M_y{__y}, _M_mdl{__mdl}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day_last&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day_last&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_day_last&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_day_last&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_mdl.month(); }

      constexpr chrono::month_day_last
      month_day_last() const noexcept
      { return _M_mdl; }


      constexpr chrono::day
      day() const noexcept
      {
 const auto __m = static_cast<unsigned>(month());
# 1875 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
 return chrono::day{__m != 2 ? (__m ^ (__m >> 3)) | 30
   : _M_y.is_leap() ? 29 : 28};
      }

      constexpr
      operator sys_days() const noexcept
      { return sys_days{year() / month() / day()}; }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_mdl.ok(); }

      friend constexpr bool
      operator==(const year_month_day_last& __x,
   const year_month_day_last& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month_day_last() == __y.month_day_last();
      }

      friend constexpr strong_ordering
      operator<=>(const year_month_day_last& __x,
    const year_month_day_last& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator+(const year_month_day_last& __ymdl,
    const months& __dm) noexcept
 { return (__ymdl.year() / __ymdl.month() + __dm) / last; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator+(const months& __dm,
    const year_month_day_last& __ymdl) noexcept
 { return __ymdl + __dm; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator-(const year_month_day_last& __ymdl,
    const months& __dm) noexcept
 { return __ymdl + -__dm; }

      friend constexpr year_month_day_last
      operator+(const year_month_day_last& __ymdl,
  const years& __dy) noexcept
      { return {__ymdl.year() + __dy, __ymdl.month_day_last()}; }

      friend constexpr year_month_day_last
      operator+(const years& __dy,
  const year_month_day_last& __ymdl) noexcept
      { return __ymdl + __dy; }

      friend constexpr year_month_day_last
      operator-(const year_month_day_last& __ymdl,
  const years& __dy) noexcept
      { return __ymdl + -__dy; }

      friend constexpr year_month_day_last
      operator/(const year_month& __ym, last_spec) noexcept
      { return {__ym.year(), chrono::month_day_last{__ym.month()}}; }

      friend constexpr year_month_day_last
      operator/(const chrono::year& __y,
  const chrono::month_day_last& __mdl) noexcept
      { return {__y, __mdl}; }

      friend constexpr year_month_day_last
      operator/(int __y, const chrono::month_day_last& __mdl) noexcept
      { return chrono::year(__y) / __mdl; }

      friend constexpr year_month_day_last
      operator/(const chrono::month_day_last& __mdl,
  const chrono::year& __y) noexcept
      { return __y / __mdl; }

      friend constexpr year_month_day_last
      operator/(const chrono::month_day_last& __mdl, int __y) noexcept
      { return chrono::year(__y) / __mdl; }
    };


    constexpr
    year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
    : _M_y{__ymdl.year()}, _M_m{__ymdl.month()}, _M_d{__ymdl.day()}
    { }

    constexpr bool
    year_month_day::ok() const noexcept
    {
      if (!_M_y.ok() || !_M_m.ok())
 return false;
      return chrono::day{1} <= _M_d && _M_d <= (_M_y / _M_m / last).day();
    }



    class year_month_weekday
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::weekday_indexed _M_wdi;

      static constexpr year_month_weekday
      _S_from_sys_days(const sys_days& __dp)
      {
 year_month_day __ymd{__dp};
 chrono::weekday __wd{__dp};
 auto __index = __wd[(unsigned{__ymd.day()} - 1) / 7 + 1];
 return {__ymd.year(), __ymd.month(), __index};
      }

    public:
      year_month_weekday() = default;

      constexpr
      year_month_weekday(const chrono::year& __y, const chrono::month& __m,
    const chrono::weekday_indexed& __wdi) noexcept
      : _M_y{__y}, _M_m{__m}, _M_wdi{__wdi}
      { }

      constexpr
      year_month_weekday(const sys_days& __dp) noexcept
      : year_month_weekday{_S_from_sys_days(__dp)}
      { }

      explicit constexpr
      year_month_weekday(const local_days& __dp) noexcept
      : year_month_weekday{sys_days{__dp.time_since_epoch()}}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_weekday&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_weekday&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wdi.weekday(); }

      constexpr unsigned
      index() const noexcept
      { return _M_wdi.index(); }

      constexpr chrono::weekday_indexed
      weekday_indexed() const noexcept
      { return _M_wdi; }

      constexpr
      operator sys_days() const noexcept
      {
 auto __d = sys_days{year() / month() / 1};
 return __d + (weekday() - chrono::weekday(__d)
        + days{(static_cast<int>(index())-1)*7});
      }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      {
 if (!_M_y.ok() || !_M_m.ok() || !_M_wdi.ok())
   return false;
 if (_M_wdi.index() <= 4)
   return true;
 days __d = (_M_wdi.weekday()
      - chrono::weekday{sys_days{_M_y / _M_m / 1}}
      + days((_M_wdi.index()-1)*7 + 1));
 do { if (std::__is_constant_evaluated() && !bool(__d.count() >= 1)) std::__glibcxx_assert_fail(); } while (false);
 return (unsigned)__d.count() <= (unsigned)(_M_y / _M_m / last).day();
      }

      friend constexpr bool
      operator==(const year_month_weekday& __x,
   const year_month_weekday& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.weekday_indexed() == __y.weekday_indexed();
      }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator+(const year_month_weekday& __ymwd, const months& __dm) noexcept
 {
   return ((__ymwd.year() / __ymwd.month() + __dm)
    / __ymwd.weekday_indexed());
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator+(const months& __dm, const year_month_weekday& __ymwd) noexcept
 { return __ymwd + __dm; }

      friend constexpr year_month_weekday
      operator+(const year_month_weekday& __ymwd, const years& __dy) noexcept
      { return {__ymwd.year() + __dy, __ymwd.month(), __ymwd.weekday_indexed()}; }

      friend constexpr year_month_weekday
      operator+(const years& __dy, const year_month_weekday& __ymwd) noexcept
      { return __ymwd + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator-(const year_month_weekday& __ymwd, const months& __dm) noexcept
 { return __ymwd + -__dm; }

      friend constexpr year_month_weekday
      operator-(const year_month_weekday& __ymwd, const years& __dy) noexcept
      { return __ymwd + -__dy; }

      friend constexpr year_month_weekday
      operator/(const year_month& __ym,
  const chrono::weekday_indexed& __wdi) noexcept
      { return {__ym.year(), __ym.month(), __wdi}; }

      friend constexpr year_month_weekday
      operator/(const chrono::year& __y, const month_weekday& __mwd) noexcept
      { return {__y, __mwd.month(), __mwd.weekday_indexed()}; }

      friend constexpr year_month_weekday
      operator/(int __y, const month_weekday& __mwd) noexcept
      { return chrono::year(__y) / __mwd; }

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, const chrono::year& __y) noexcept
      { return __y / __mwd; }

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, int __y) noexcept
      { return chrono::year(__y) / __mwd; }
    };



    class year_month_weekday_last
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::weekday_last _M_wdl;

    public:
      constexpr
      year_month_weekday_last(const chrono::year& __y, const chrono::month& __m,
         const chrono::weekday_last& __wdl) noexcept
      : _M_y{__y}, _M_m{__m}, _M_wdl{__wdl}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday_last&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday_last&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_weekday_last&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_weekday_last&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wdl.weekday(); }

      constexpr chrono::weekday_last
      weekday_last() const noexcept
      { return _M_wdl; }

      constexpr
      operator sys_days() const noexcept
      {
 const auto __d = sys_days{_M_y / _M_m / last};
 return sys_days{(__d - (chrono::weekday{__d}
    - _M_wdl.weekday())).time_since_epoch()};
      }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_m.ok() && _M_wdl.ok(); }

      friend constexpr bool
      operator==(const year_month_weekday_last& __x,
   const year_month_weekday_last& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.weekday_last() == __y.weekday_last();
      }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator+(const year_month_weekday_last& __ymwdl,
    const months& __dm) noexcept
 {
   return ((__ymwdl.year() / __ymwdl.month() + __dm)
    / __ymwdl.weekday_last());
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator+(const months& __dm,
    const year_month_weekday_last& __ymwdl) noexcept
 { return __ymwdl + __dm; }

      friend constexpr year_month_weekday_last
      operator+(const year_month_weekday_last& __ymwdl,
  const years& __dy) noexcept
      { return {__ymwdl.year() + __dy, __ymwdl.month(), __ymwdl.weekday_last()}; }

      friend constexpr year_month_weekday_last
      operator+(const years& __dy,
  const year_month_weekday_last& __ymwdl) noexcept
      { return __ymwdl + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator-(const year_month_weekday_last& __ymwdl,
    const months& __dm) noexcept
 { return __ymwdl + -__dm; }

      friend constexpr year_month_weekday_last
      operator-(const year_month_weekday_last& __ymwdl,
  const years& __dy) noexcept
      { return __ymwdl + -__dy; }

      friend constexpr year_month_weekday_last
      operator/(const year_month& __ym,
  const chrono::weekday_last& __wdl) noexcept
      { return {__ym.year(), __ym.month(), __wdl}; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::year& __y,
  const chrono::month_weekday_last& __mwdl) noexcept
      { return {__y, __mwdl.month(), __mwdl.weekday_last()}; }

      friend constexpr year_month_weekday_last
      operator/(int __y, const chrono::month_weekday_last& __mwdl) noexcept
      { return chrono::year(__y) / __mwdl; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::month_weekday_last& __mwdl,
  const chrono::year& __y) noexcept
      { return __y / __mwdl; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::month_weekday_last& __mwdl, int __y) noexcept
      { return chrono::year(__y) / __mwdl; }
    };




    namespace __detail
    {
      consteval long long
      __pow10(unsigned __n)
      {
 long long __r = 1;
 while (__n-- > 0)
   __r *= 10;
 return __r;
      }

      template<typename _Duration> struct __utc_leap_second;
    }
# 2320 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
    template<typename _Duration>
      class hh_mm_ss
      {
 static_assert( __is_duration<_Duration>::value );

      private:
 static consteval int
 _S_fractional_width()
 {
   auto __den = _Duration::period::den;
   const int __multiplicity_2 = std::__countr_zero((uintmax_t)__den);
   __den >>= __multiplicity_2;
   int __multiplicity_5 = 0;
   while ((__den % 5) == 0)
     {
       ++__multiplicity_5;
       __den /= 5;
     }
   if (__den != 1)
     return 6;

   int __width = (__multiplicity_2 > __multiplicity_5
    ? __multiplicity_2 : __multiplicity_5);
   if (__width > 18)
     __width = 18;
   return __width;
 }

 constexpr
 hh_mm_ss(_Duration __d, bool __is_neg)
 : _M_h (duration_cast<chrono::hours>(__d)),
   _M_m (duration_cast<chrono::minutes>(__d - hours())),
   _M_s (duration_cast<chrono::seconds>(__d - hours() - minutes())),
   _M_is_neg(__is_neg)
 {
   auto __ss = __d - hours() - minutes() - seconds();
   if constexpr (treat_as_floating_point_v<typename precision::rep>)
     _M_ss._M_r = __ss.count();
   else if constexpr (precision::period::den != 1)
     _M_ss._M_r = duration_cast<precision>(__ss).count();
 }

 static constexpr _Duration
 _S_abs(_Duration __d)
 {
   if constexpr (numeric_limits<typename _Duration::rep>::is_signed)
     return chrono::abs(__d);
   else
     return __d;
 }

      public:
 static constexpr unsigned fractional_width = {_S_fractional_width()};

 using precision
   = duration<common_type_t<typename _Duration::rep,
       chrono::seconds::rep>,
       ratio<1, __detail::__pow10(fractional_width)>>;

 constexpr hh_mm_ss() noexcept = default;

 constexpr explicit
 hh_mm_ss(_Duration __d)
 : hh_mm_ss(_S_abs(__d), __d < _Duration::zero())
 { }

 constexpr bool
 is_negative() const noexcept
 {
   if constexpr (!_S_is_unsigned)
     return _M_is_neg;
   else
     return false;
 }

 constexpr chrono::hours
 hours() const noexcept
 { return _M_h; }

 constexpr chrono::minutes
 minutes() const noexcept
 { return _M_m; }

 constexpr chrono::seconds
 seconds() const noexcept
 { return _M_s; }

 constexpr precision
 subseconds() const noexcept
 { return static_cast<precision>(_M_ss); }

 constexpr explicit
 operator precision() const noexcept
 { return to_duration(); }

 constexpr precision
 to_duration() const noexcept
 {
   if constexpr (!_S_is_unsigned)
     if (_M_is_neg)
       return -(_M_h + _M_m + _M_s + subseconds());
   return _M_h + _M_m + _M_s + subseconds();
 }

      private:
 static constexpr bool _S_is_unsigned
   = __and_v<is_integral<typename _Duration::rep>,
      is_unsigned<typename _Duration::rep>>;

 template<typename _Ratio>
   using __byte_duration = duration<unsigned char, _Ratio>;


 template<typename _Dur>
   struct __subseconds
   {
     typename _Dur::rep _M_r{};

     constexpr explicit
     operator _Dur() const noexcept
     { return _Dur(_M_r); }
   };


 template<typename _Rep>
   requires (!treat_as_floating_point_v<_Rep>)
   struct __subseconds<duration<_Rep, ratio<1>>>
   {
     constexpr explicit
     operator duration<_Rep, ratio<1>>() const noexcept
     { return {}; }
   };

 template<typename _Rep, typename _Period>
   requires (!treat_as_floating_point_v<_Rep>)
     && ratio_less_v<_Period, ratio<1, 1>>
     && ratio_greater_equal_v<_Period, ratio<1, 250>>
   struct __subseconds<duration<_Rep, _Period>>
   {
     unsigned char _M_r{};

     constexpr explicit
     operator duration<_Rep, _Period>() const noexcept
     { return duration<_Rep, _Period>(_M_r); }
   };

 template<typename _Rep, typename _Period>
   requires (!treat_as_floating_point_v<_Rep>)
     && ratio_less_v<_Period, ratio<1, 250>>
     && ratio_greater_equal_v<_Period, ratio<1, 4000000000>>
   struct __subseconds<duration<_Rep, _Period>>
   {
     uint_least32_t _M_r{};

     constexpr explicit
     operator duration<_Rep, _Period>() const noexcept
     { return duration<_Rep, _Period>(_M_r); }
   };

 chrono::hours _M_h{};
 __byte_duration<ratio<60>> _M_m{};
 __byte_duration<ratio<1>> _M_s{};
 bool _M_is_neg{};
 __subseconds<precision> _M_ss{};

 template<typename> friend struct __detail::__utc_leap_second;
      };


    namespace __detail
    {

      template<typename _Duration>
 struct __utc_leap_second
 {
   explicit
   __utc_leap_second(const sys_time<_Duration>& __s)
   : _M_date(chrono::floor<days>(__s)), _M_time(__s - _M_date)
   {
     ++_M_time._M_s;
   }

   sys_days _M_date;
   hh_mm_ss<common_type_t<_Duration, days>> _M_time;
 };
    }




    constexpr bool
    is_am(const hours& __h) noexcept
    { return 0h <= __h && __h <= 11h; }

    constexpr bool
    is_pm(const hours& __h) noexcept
    { return 12h <= __h && __h <= 23h; }

    constexpr hours
    make12(const hours& __h) noexcept
    {
      if (__h == 0h)
 return 12h;
      else if (__h > 12h)
 return __h - 12h;
      return __h;
    }

    constexpr hours
    make24(const hours& __h, bool __is_pm) noexcept
    {
      if (!__is_pm)
 {
   if (__h == 12h)
     return 0h;
   else
     return __h;
 }
      else
 {
   if (__h == 12h)
     return __h;
   else
     return __h + 12h;
 }
    }





    struct tzdb;

    struct sys_info
    {
      sys_seconds begin;
      sys_seconds end;
      seconds offset;
      minutes save;
      string abbrev;
    };

    struct local_info
    {
      static constexpr int unique = 0;
      static constexpr int nonexistent = 1;
      static constexpr int ambiguous = 2;

      int result;
      sys_info first;
      sys_info second;
    };

    class nonexistent_local_time : public runtime_error
    {
    public:
      template<typename _Duration>
 nonexistent_local_time(const local_time<_Duration>& __tp,
          const local_info& __i)
 : runtime_error(_S_make_what_str(__tp, __i))
 { do { if (std::__is_constant_evaluated() && !bool(__i.result == local_info::nonexistent)) std::__glibcxx_assert_fail(); } while (false); }

    private:
      template<typename _Duration>
 static string
 _S_make_what_str(const local_time<_Duration>& __tp,
    const local_info& __i)
 {
   std::ostringstream __os;
   __os << __tp << " is in a gap between\n"
        << local_seconds(__i.first.end.time_since_epoch())
        + __i.first.offset << ' ' << __i.first.abbrev << " and\n"
        << local_seconds(__i.second.begin.time_since_epoch())
        + __i.second.offset << ' ' << __i.second.abbrev
        << " which are both equivalent to\n"
        << __i.first.end << " UTC";
   return std::move(__os).str();
 }
    };

    class ambiguous_local_time : public runtime_error
    {
    public:
      template<typename _Duration>
 ambiguous_local_time(const local_time<_Duration>& __tp,
        const local_info& __i)
 : runtime_error(_S_make_what_str(__tp, __i))
 { do { if (std::__is_constant_evaluated() && !bool(__i.result == local_info::ambiguous)) std::__glibcxx_assert_fail(); } while (false); }

    private:
      template<typename _Duration>
 static string
 _S_make_what_str(const local_time<_Duration>& __tp,
    const local_info& __i)
 {
   std::ostringstream __os;
   __os << __tp << " is ambiguous.  It could be\n"
        << __tp << ' ' << __i.first.abbrev << " == "
        << __tp - __i.first.offset << " UTC or\n"
        << __tp << ' ' << __i.second.abbrev << " == "
        << __tp - __i.second.offset << " UTC";
   return std::move(__os).str();
 }
    };

    template<typename _Duration>
      [[noreturn]] void
      __throw_bad_local_time(const local_time<_Duration>& __tp,
        const local_info& __i)
      {

 if (__i.result == local_info::nonexistent)
   throw nonexistent_local_time(__tp, __i);
 throw ambiguous_local_time(__tp, __i);



      }

    enum class choose { earliest, latest };

    class time_zone
    {
    public:
      time_zone(time_zone&&) = default;
      time_zone& operator=(time_zone&&) = default;

      ~time_zone();

      [[nodiscard]]
      string_view name() const noexcept { return _M_name; }

      template<typename _Duration>
 sys_info
 get_info(const sys_time<_Duration>& __st) const
 { return _M_get_sys_info(chrono::floor<seconds>(__st)); }

      template<typename _Duration>
 local_info
 get_info(const local_time<_Duration>& __tp) const
 { return _M_get_local_info(chrono::floor<seconds>(__tp)); }

      template<typename _Duration>
 sys_time<common_type_t<_Duration, seconds>>
 to_sys(const local_time<_Duration>& __tp) const
 {
   local_info __info = get_info(__tp);

   if (__info.result != local_info::unique)
     __throw_bad_local_time(__tp, __info);

   return sys_time<_Duration>(__tp.time_since_epoch())
     - __info.first.offset;
 }

      template<typename _Duration>
 sys_time<common_type_t<_Duration, seconds>>
 to_sys(const local_time<_Duration>& __tp, choose __z) const
 {
   local_info __info = get_info(__tp);

   if (__info.result == local_info::nonexistent)
     return __info.first.end;

   sys_time<_Duration> __st(__tp.time_since_epoch());

   if (__info.result == local_info::ambiguous && __z == choose::latest)
     return __st - __info.second.offset;


   return __st - __info.first.offset;
 }

      template<typename _Duration>
 local_time<common_type_t<_Duration, seconds>>
 to_local(const sys_time<_Duration>& __tp) const
 {
   auto __d = (__tp + get_info(__tp).offset).time_since_epoch();
   return local_time<common_type_t<_Duration, seconds>>(__d);
 }

      [[nodiscard]] friend bool
      operator==(const time_zone& __x, const time_zone& __y) noexcept
      { return __x._M_name == __y._M_name; }

      [[nodiscard]] friend strong_ordering
      operator<=>(const time_zone& __x, const time_zone& __y) noexcept
      { return __x._M_name <=> __y._M_name; }

    private:
      sys_info _M_get_sys_info(sys_seconds) const;
      local_info _M_get_local_info(local_seconds) const;

      friend const tzdb& reload_tzdb();
      friend struct tzdb;
      friend class tzdb_list;

      struct _Impl;

      explicit time_zone(unique_ptr<_Impl> __p);
      string _M_name;
      unique_ptr<_Impl> _M_impl;
    };

    const time_zone* locate_zone(string_view __tz_name);
    const time_zone* current_zone();
# 2741 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
    class tzdb_list
    {
      struct _Node;

    public:
      tzdb_list(const tzdb_list&) = delete;
      tzdb_list& operator=(const tzdb_list&) = delete;
# 2756 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
      class const_iterator
      {
      public:
 using value_type = tzdb;
 using reference = const tzdb&;
 using pointer = const tzdb*;
 using difference_type = ptrdiff_t;
 using iterator_category = forward_iterator_tag;

 constexpr const_iterator() = default;
 const_iterator(const const_iterator&) = default;
 const_iterator(const_iterator&&) = default;
 const_iterator& operator=(const const_iterator&) = default;
 const_iterator& operator=(const_iterator&&) = default;

 reference operator*() const noexcept;
 pointer operator->() const noexcept { return &**this; }
 const_iterator& operator++();
 const_iterator operator++(int);

 bool operator==(const const_iterator&) const noexcept = default;

      private:
 explicit const_iterator(const shared_ptr<_Node>&) noexcept;

 friend class tzdb_list;

 shared_ptr<_Node> _M_node;
 void* _M_reserved = nullptr;
      };
# 2794 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
      const tzdb& front() const noexcept;
# 2810 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 3
      const_iterator erase_after(const_iterator __p);

      const_iterator begin() const noexcept;
      const_iterator end() const noexcept { return {}; }
      const_iterator cbegin() const noexcept { return begin(); }
      const_iterator cend() const noexcept { return end(); }

    private:
      constexpr explicit tzdb_list(nullptr_t);

      friend tzdb_list& get_tzdb_list();
      friend const tzdb& get_tzdb();
      friend const tzdb& reload_tzdb();
      friend struct tzdb;
      friend class leap_second;
      friend struct time_zone::_Impl;
      friend class time_zone_link;
    };

    class time_zone_link
    {
    public:
      time_zone_link(time_zone_link&&) = default;
      time_zone_link& operator=(time_zone_link&&) = default;

      string_view name() const noexcept { return _M_name; }
      string_view target() const noexcept { return _M_target; }

      friend bool
      operator==(const time_zone_link& __x, const time_zone_link& __y) noexcept
      { return __x.name() == __y.name(); }

      friend strong_ordering
      operator<=>(const time_zone_link& __x, const time_zone_link& __y) noexcept
      { return __x.name() <=> __y.name(); }

    private:
      friend const tzdb& reload_tzdb();
      friend struct tzdb_list::_Node;

      explicit time_zone_link(nullptr_t) { }

      string _M_name;
      string _M_target;
    };

    class leap_second
    {
    public:
      leap_second(const leap_second&) = default;
      leap_second& operator=(const leap_second&) = default;

      [[nodiscard]]
      constexpr sys_seconds
      date() const noexcept
      {
 if (_M_s >= _M_s.zero()) [[likely]]
   return sys_seconds(_M_s);
 return sys_seconds(-_M_s);
      }

      [[nodiscard]]
      constexpr seconds
      value() const noexcept
      {
 if (_M_s >= _M_s.zero()) [[likely]]
   return seconds(1);
 return seconds(-1);
      }



      [[nodiscard]] friend constexpr bool
      operator==(const leap_second&, const leap_second&) noexcept = default;

      [[nodiscard]] friend constexpr strong_ordering
      operator<=>(const leap_second& __x, const leap_second& __y) noexcept
      { return __x.date() <=> __y.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator==(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return __x.date() == __y; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<(const leap_second& __x,
    const sys_time<_Duration>& __y) noexcept
 { return __x.date() < __y; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<(const sys_time<_Duration>& __x,
    const leap_second& __y) noexcept
 { return __x < __y.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>(const leap_second& __x,
    const sys_time<_Duration>& __y) noexcept
 { return __y < __x.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>(const sys_time<_Duration>& __x,
    const leap_second& __y) noexcept
 { return __y.date() < __x; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<=(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return !(__y < __x.date()); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<=(const sys_time<_Duration>& __x,
     const leap_second& __y) noexcept
 { return !(__y.date() < __x); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>=(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return !(__x.date() < __y); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>=(const sys_time<_Duration>& __x,
     const leap_second& __y) noexcept
 { return !(__x < __y.date()); }



      template<three_way_comparable_with<seconds> _Duration>
 [[nodiscard]] friend constexpr auto
 operator<=>(const leap_second& __x,
      const sys_time<_Duration>& __y) noexcept
 { return __x.date() <=> __y; }

    private:
      explicit leap_second(seconds::rep __s) : _M_s(__s) { }

      friend struct tzdb_list::_Node;

      friend const tzdb& reload_tzdb();

      template<typename _Duration>
 friend leap_second_info
 get_leap_second_info(const utc_time<_Duration>&);

      seconds _M_s;
    };

    template<class _Tp> struct zoned_traits { };

    template<>
      struct zoned_traits<const time_zone*>
      {
 static const time_zone*
 default_zone()
 { return std::chrono::locate_zone("UTC"); }

 static const time_zone*
 locate_zone(string_view __name)
 { return std::chrono::locate_zone(__name); }
      };

    struct tzdb
    {
      string version;
      std::vector<time_zone> zones;
      std::vector<time_zone_link> links;
      std::vector<leap_second> leap_seconds;

      const time_zone*
      locate_zone(string_view __tz_name) const;

      const time_zone*
      current_zone() const;

    private:
      friend const tzdb& reload_tzdb();
      friend class time_zone;
      friend struct tzdb_list::_Node;
    };

    tzdb_list& get_tzdb_list();
    const tzdb& get_tzdb();

    const tzdb& reload_tzdb();
    string remote_version();

    template<typename _Duration, typename _TimeZonePtr = const time_zone*>
      class zoned_time
      {
 static_assert(__is_duration_v<_Duration>);

 using _Traits = zoned_traits<_TimeZonePtr>;



 using string_view = type_identity_t<std::string_view>;

      public:
 using duration = common_type_t<_Duration, seconds>;

 zoned_time() requires requires { _Traits::default_zone(); }
 { }

 zoned_time(const zoned_time&) = default;
 zoned_time& operator=(const zoned_time&) = default;

 zoned_time(const sys_time<_Duration>& __st)
   requires requires { _Traits::default_zone(); }
 : _M_tp(__st)
 { }

 explicit
 zoned_time(_TimeZonePtr __z) : _M_zone(std::move(__z)) { }

 explicit
 zoned_time(string_view __name)
   requires requires {
     _TimeZonePtr{_Traits::locate_zone(std::string_view{})};
   }
 : _M_zone(_Traits::locate_zone(__name))
 { }

 template<typename _Duration2>
   zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__zt._M_zone), _M_tp(__zt._M_tp)
   { }

 zoned_time(_TimeZonePtr __z, const sys_time<_Duration>& __st)
 : _M_zone(std::move(__z)), _M_tp(__st)
 { }

 zoned_time(string_view __name, const sys_time<_Duration>& __st)
 : zoned_time(_Traits::locate_zone(__name), __st)
 { }

 zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp)
 requires requires {
   { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp))
 { }

 zoned_time(string_view __name, const local_time<_Duration>& __tp)
 requires requires (_TimeZonePtr __z) {
   { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
 }
 : zoned_time(_Traits::locate_zone(__name), __tp)
 { }

 zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp,
     choose __c)
 requires requires {
   { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp, __c))
 { }

 zoned_time(string_view __name, const local_time<_Duration>& __tp,
     choose __c)
 requires requires (_TimeZonePtr __z) {
   { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(_Traits::locate_zone(__name)),
   _M_tp(_M_zone->to_sys(__tp, __c))
 { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(_TimeZonePtr __z,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__z), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(_TimeZonePtr __z,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
       choose)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__z), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(string_view __name,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   && requires {
     { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   }
   : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(string_view __name,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
       choose)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   && requires {
     { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   }
   : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
   { }

 zoned_time&
 operator=(const sys_time<_Duration>& __st)
 {
   _M_tp = __st;
   return *this;
 }

 zoned_time&
 operator=(const local_time<_Duration>& __lt)
 {
   _M_tp = _M_zone->to_sys(__lt);
   return *this;
 }

 [[nodiscard]]
 operator sys_time<duration>() const { return _M_tp; }

 [[nodiscard]]
 explicit operator local_time<duration>() const
 { return get_local_time(); }

 [[nodiscard]]
 _TimeZonePtr
 get_time_zone() const
 { return _M_zone; }

 [[nodiscard]]
 local_time<duration>
 get_local_time() const
 { return _M_zone->to_local(_M_tp); }

 [[nodiscard]]
 sys_time<duration>
 get_sys_time() const
 { return _M_tp; }

 [[nodiscard]]
 sys_info
 get_info() const
 { return _M_zone->get_info(_M_tp); }

 [[nodiscard]] friend bool
 operator==(const zoned_time&, const zoned_time&) = default;

      private:
 _TimeZonePtr _M_zone{ _Traits::default_zone() };
 sys_time<duration> _M_tp{};

 template<typename _Duration2, typename _TimeZonePtr2>
   friend class zoned_time;
      };

    zoned_time() -> zoned_time<seconds>;

    template<typename _Duration>
    zoned_time(sys_time<_Duration>)
      -> zoned_time<common_type_t<_Duration, seconds>>;


  template<typename _TimeZonePtrOrName>
    using __time_zone_representation
      = __conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>,
   const time_zone*,
   remove_cvref_t<_TimeZonePtrOrName>>;


  template<typename _TimeZonePtrOrName>
    zoned_time(_TimeZonePtrOrName&&)
      -> zoned_time<seconds, __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _TimeZonePtrOrName, typename _Duration>
    zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _TimeZonePtrOrName, typename _Duration>
    zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _Duration, typename _TimeZonePtrOrName,
    typename _TimeZonePtr2>
    zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _Dur1, typename _TZPtr1, typename _Dur2, typename _TZPtr2>
    [[nodiscard]]
    inline bool
    operator==(const zoned_time<_Dur1, _TZPtr1>& __x,
        const zoned_time<_Dur2, _TZPtr2>& __y)
    {
      return __x.get_time_zone() == __y.get_time_zone()
        && __x.get_sys_time() == __y.get_sys_time();
    }

    using zoned_seconds = zoned_time<seconds>;


namespace __detail
{
    inline leap_second_info
    __get_leap_second_info(sys_seconds __ss, bool __is_utc)
    {
      if (__ss < sys_seconds{}) [[unlikely]]
 return {};

      const seconds::rep __leaps[] {
   78796800,
   94694400,
  126230400,
  157766400,
  189302400,
  220924800,
  252460800,
  283996800,
  315532800,
  362793600,
  394329600,
  425865600,
  489024000,
  567993600,
  631152000,
  662688000,
  709948800,
  741484800,
  773020800,
  820454400,
  867715200,
  915148800,
 1136073600,
 1230768000,
 1341100800,
 1435708800,
 1483228800,
      };


      const sys_seconds __expires(1766880000s);


      if (__ss > __expires)
 {

   size_t __n = std::size(__leaps);

   auto __db = get_tzdb_list().begin();
   auto __first = __db->leap_seconds.begin() + __n;
   auto __last = __db->leap_seconds.end();
   auto __pos = std::upper_bound(__first, __last, __ss);
   seconds __elapsed(__n);
   for (auto __i = __first; __i != __pos; ++__i)
     __elapsed += __i->value();

   if (__is_utc)
     {

       __ss -= __elapsed;

       if (__pos != __first && __ss < __pos[-1])
  {
    if ((__ss + 1s) >= __pos[-1])
      return {true, __elapsed};
    __elapsed -= __pos[-1].value();
  }
     }
   return {false, __elapsed};
 }
      else

 {
   seconds::rep __s = __ss.time_since_epoch().count();
   const seconds::rep* __first = std::begin(__leaps);
   const seconds::rep* __last = std::end(__leaps);


   if (__s > (__last[-1] + (__last - __first) + 1))
     return { false, seconds(__last - __first) };

   auto __pos = std::upper_bound(__first, __last, __s);
   seconds __elapsed{__pos - __first};
   if (__is_utc)
     {

       __s -= __elapsed.count();

       if (__pos != __first && __s < __pos[-1])
  {
    if ((__s + 1) >= __pos[-1])
      return {true, __elapsed};
    --__elapsed;
  }
     }
   return {false, __elapsed};
 }
    }
}

    template<typename _Duration>
      [[nodiscard]]
      inline leap_second_info
      get_leap_second_info(const utc_time<_Duration>& __ut)
      {
 auto __s = chrono::duration_cast<seconds>(__ut.time_since_epoch());
 return __detail::__get_leap_second_info(sys_seconds(__s), true);
      }

    template<typename _Duration>
      [[nodiscard]]
      inline utc_time<common_type_t<_Duration, seconds>>
      utc_clock::from_sys(const sys_time<_Duration>& __t)
      {
 using _CDur = common_type_t<_Duration, seconds>;
 auto __s = chrono::time_point_cast<seconds>(__t);
 const auto __li = __detail::__get_leap_second_info(__s, false);
 return utc_time<_CDur>{__t.time_since_epoch()} + __li.elapsed;
      }




  }


  inline namespace literals
  {
  inline namespace chrono_literals
  {


#pragma GCC diagnostic push



    constexpr chrono::day
    operator""d(unsigned long long __d) noexcept
    { return chrono::day{static_cast<unsigned>(__d)}; }



    constexpr chrono::year
    operator""y(unsigned long long __y) noexcept
    { return chrono::year{static_cast<int>(__y)}; }
#pragma GCC diagnostic pop

  }
  }



}


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  struct to_chars_result
  {
    char* ptr;
    errc ec;


    friend bool
    operator==(const to_chars_result&, const to_chars_result&) = default;




  };


  struct from_chars_result
  {
    const char* ptr;
    errc ec;


    friend bool
    operator==(const from_chars_result&, const from_chars_result&) = default;




  };

namespace __detail
{





  template<typename _Tp>
    struct __to_chars_unsigned_type : __make_unsigned_selector_base
    {
      using _UInts = _List<unsigned int, unsigned long, unsigned long long

 , unsigned __int128

 >;
      using type = typename __select<sizeof(_Tp), _UInts>::__type;
    };

  template<typename _Tp>
    using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;



  template<typename _Tp>
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base ) noexcept;

  template<typename _Tp>
    constexpr unsigned
    __to_chars_len_2(_Tp __value) noexcept
    { return std::__bit_width(__value); }


  template<typename _Tp>
    constexpr to_chars_result
    __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, __base);

      if (__builtin_expect(size_t(__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;

      constexpr char __digits[] = {
 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
 'u', 'v', 'w', 'x', 'y', 'z'
      };

      while (__val >= (unsigned)__base)
 {
   auto const __quo = __val / __base;
   auto const __rem = __val % __base;
   __first[__pos--] = __digits[__rem];
   __val = __quo;
 }
      *__first = __digits[__val];

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;

      if (__builtin_expect(size_t(__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      constexpr char __digits[] = {
 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 'a', 'b', 'c', 'd', 'e', 'f'
      };
      unsigned __pos = __len - 1;
      while (__val >= 0x100)
 {
   auto __num = __val & 0xF;
   __val >>= 4;
   __first[__pos] = __digits[__num];
   __num = __val & 0xF;
   __val >>= 4;
   __first[__pos - 1] = __digits[__num];
   __pos -= 2;
 }
      if (__val >= 0x10)
 {
   const auto __num = __val & 0xF;
   __val >>= 4;
   __first[1] = __digits[__num];
   __first[0] = __digits[__val];
 }
      else
 __first[0] = __digits[__val];
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, 10);

      if (__builtin_expect(size_t(__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      __detail::__to_chars_10_impl(__first, __len, __val);
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;
      unsigned __len = 0;

      if constexpr (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
 {
   __len = __val > 077777u ? 6u
     : __val > 07777u ? 5u
     : __val > 0777u ? 4u
     : __val > 077u ? 3u
     : __val > 07u ? 2u
     : 1u;
 }
      else
 __len = (__to_chars_len_2(__val) + 2) / 3;

      if (__builtin_expect(size_t(__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;
      while (__val >= 0100)
 {
   auto __num = __val & 7;
   __val >>= 3;
   __first[__pos] = '0' + __num;
   __num = __val & 7;
   __val >>= 3;
   __first[__pos - 1] = '0' + __num;
   __pos -= 2;
 }
      if (__val >= 010)
 {
   auto const __num = __val & 7;
   __val >>= 3;
   __first[1] = '0' + __num;
   __first[0] = '0' + __val;
 }
      else
 __first[0] = '0' + __val;
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len_2(__val);

      if (__builtin_expect(size_t(__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;

      while (__pos)
 {
   __first[__pos--] = '0' + (__val & 1);
   __val >>= 1;
 }



      __first[0] = '1';

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

}

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
    {
      do { if (std::__is_constant_evaluated() && !bool(2 <= __base && __base <= 36)) std::__glibcxx_assert_fail(); } while (false);

      using _Up = __detail::__unsigned_least_t<_Tp>;
      _Up __unsigned_val = __value;

      if (__first >= __last) [[__unlikely__]]
 return { __last, errc::value_too_large };

      if (__value == 0)
 {
   *__first = '0';
   return { __first + 1, errc{} };
 }
      else if constexpr (std::is_signed<_Tp>::value)
 if (__value < 0)
   {
     *__first++ = '-';
     __unsigned_val = _Up(~__value) + _Up(1);
   }

      switch (__base)
      {
      case 16:
 return __detail::__to_chars_16(__first, __last, __unsigned_val);
      case 10:
 return __detail::__to_chars_10(__first, __last, __unsigned_val);
      case 8:
 return __detail::__to_chars_8(__first, __last, __unsigned_val);
      case 2:
 return __detail::__to_chars_2(__first, __last, __unsigned_val);
      default:
 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
      }
    }





 inline to_chars_result to_chars(char* __first, char* __last, char __value, int __base = 10) { return std::__to_chars_i<char>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, signed char __value, int __base = 10) { return std::__to_chars_i<signed char>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, unsigned char __value, int __base = 10) { return std::__to_chars_i<unsigned char>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, signed short __value, int __base = 10) { return std::__to_chars_i<signed short>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, unsigned short __value, int __base = 10) { return std::__to_chars_i<unsigned short>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, signed int __value, int __base = 10) { return std::__to_chars_i<signed int>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, unsigned int __value, int __base = 10) { return std::__to_chars_i<unsigned int>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, signed long __value, int __base = 10) { return std::__to_chars_i<signed long>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, unsigned long __value, int __base = 10) { return std::__to_chars_i<unsigned long>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, signed long long __value, int __base = 10) { return std::__to_chars_i<signed long long>(__first, __last, __value, __base); }
 inline to_chars_result to_chars(char* __first, char* __last, unsigned long long __value, int __base = 10) { return std::__to_chars_i<unsigned long long>(__first, __last, __value, __base); }
# 396 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
  to_chars_result to_chars(char*, char*, bool, int = 10) = delete;

namespace __detail
{
  template<typename _Tp>
    constexpr bool
    __raise_and_add(_Tp& __val, int __base, unsigned char __c)
    {
      if (__builtin_mul_overflow(__val, __base, &__val)
   || __builtin_add_overflow(__val, __c, &__val))
 return false;
      return true;
    }

  template<bool _DecOnly>
    struct __from_chars_alnum_to_val_table
    {
      struct type { unsigned char __data[1u << 8] = {}; };



      static constexpr type
      _S_make_table()
      {
 constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz";
 constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 type __table;
 for (auto& __entry : __table.__data)
   __entry = 127;
 for (int __i = 0; __i < 10; ++__i)
   __table.__data['0' + __i] = __i;
 for (int __i = 0; __i < 26; ++__i)
   {
     __table.__data[__lower_letters[__i]] = 10 + __i;
     __table.__data[__upper_letters[__i]] = 10 + __i;
   }
 return __table;
      }




      static constexpr type value = (_DecOnly, _S_make_table());
    };
# 451 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
  template<bool _DecOnly = false>
    constexpr unsigned char
    __from_chars_alnum_to_val(unsigned char __c)
    {
      if constexpr (_DecOnly)
 return static_cast<unsigned char>(__c - '0');
      else
 return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
    }



  template<bool _DecOnly, typename _Tp>
                         bool
    __from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val,
      int __base)
    {
      static_assert(is_integral<_Tp>::value, "implementation bug");
      static_assert(is_unsigned<_Tp>::value, "implementation bug");



      const int __log2_base = __countr_zero(unsigned(__base & 0x3f));

      const ptrdiff_t __len = __last - __first;
      ptrdiff_t __i = 0;
      while (__i < __len && __first[__i] == '0')
 ++__i;
      const ptrdiff_t __leading_zeroes = __i;
      if (__i >= __len) [[__unlikely__]]
 {
   __first += __i;
   return true;
 }


      unsigned char __leading_c = 0;
      if (__base != 2)
 {
   __leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);

   if (__leading_c >= __base) [[__unlikely__]]
     {
       __first += __i;
       return true;
     }
   __val = __leading_c;
   ++__i;
 }

      for (; __i < __len; ++__i)
 {
   const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
   if (__c >= __base)
     break;
   __val = (__val << __log2_base) | __c;
 }
      __first += __i;
      auto __significant_bits = (__i - __leading_zeroes) * __log2_base;
      if (__base != 2)


 __significant_bits -= __log2_base - __bit_width(__leading_c);

      return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits;
    }



  template<bool _DecOnly, typename _Tp>
    constexpr bool
    __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
         int __base)
    {


      const int __bits_per_digit = __bit_width(unsigned(__base & 0x3f));
      int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
      for (; __first != __last; ++__first)
 {
   const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first);
   if (__c >= __base)
     return true;

   __unused_bits_lower_bound -= __bits_per_digit;
   if (__unused_bits_lower_bound >= 0) [[__likely__]]

     __val = __val * __base + __c;
   else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]]
     {
       while (++__first != __last
       && __from_chars_alnum_to_val<_DecOnly>(*__first) < __base)
  ;
       return false;
     }
 }
      return true;
    }

}


  template<typename _Tp,
    enable_if_t<__or_<__is_standard_integer<_Tp>,
        is_same<char, remove_cv_t<_Tp>>>::value, int> = 0>
                         from_chars_result
    from_chars(const char* __first, const char* __last, _Tp& __value,
        int __base = 10)
    {
      do { if (std::__is_constant_evaluated() && !bool(2 <= __base && __base <= 36)) std::__glibcxx_assert_fail(); } while (false);

      from_chars_result __res{__first, {}};

      int __sign = 1;
      if constexpr (std::is_signed<_Tp>::value)
 if (__first != __last && *__first == '-')
   {
     __sign = -1;
     ++__first;
   }

      using _Up = __detail::__unsigned_least_t<_Tp>;
      _Up __val = 0;

      const auto __start = __first;
      bool __valid;
      if ((__base & (__base - 1)) == 0)
 {
   if (__base <= 8)
     __valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
   else
     __valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
 }
      else if (__base <= 10)
 __valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
      else
 __valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);

      if (__builtin_expect(__first == __start, 0))
 __res.ec = errc::invalid_argument;
      else
 {
   __res.ptr = __first;
   if (!__valid)
     __res.ec = errc::result_out_of_range;
   else
     {
       if constexpr (std::is_signed<_Tp>::value)
  {
    _Tp __tmp;
    if (__builtin_mul_overflow(__val, __sign, &__tmp))
      __res.ec = errc::result_out_of_range;
    else
      __value = __tmp;
  }
       else
  {
    if constexpr (__gnu_cxx::__int_traits<_Up>::__max
        > __gnu_cxx::__int_traits<_Tp>::__max)
      {
        if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
   __res.ec = errc::result_out_of_range;
        else
   __value = __val;
      }
    else
      __value = __val;
  }
     }
 }
      return __res;
    }


  enum class chars_format
  {
    scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
  };

  [[nodiscard]]
  constexpr chars_format
  operator|(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator&(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator^(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator~(chars_format __fmt) noexcept
  { return (chars_format)~(unsigned)__fmt; }

  constexpr chars_format&
  operator|=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs | __rhs; }

  constexpr chars_format&
  operator&=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs & __rhs; }

  constexpr chars_format&
  operator^=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs ^ __rhs; }


  from_chars_result
  from_chars(const char* __first, const char* __last, float& __value,
      chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, double& __value,
      chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, long double& __value,
      chars_format __fmt = chars_format::general) noexcept;



  from_chars_result
  __from_chars_float16_t(const char* __first, const char* __last,
    float& __value,
    chars_format __fmt = chars_format::general) noexcept;
  from_chars_result
  __from_chars_bfloat16_t(const char* __first, const char* __last,
     float& __value,
     chars_format __fmt = chars_format::general) noexcept;
# 782 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
  to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
      chars_format __fmt, int __precision) noexcept;


  to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
      chars_format __fmt, int __precision) noexcept;


  to_chars_result to_chars(char* __first, char* __last, long double __value)
    noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
      chars_format __fmt, int __precision) noexcept;



  to_chars_result __to_chars_float16_t(char* __first, char* __last,
           float __value,
           chars_format __fmt) noexcept;
  to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
     float __value,
     chars_format __fmt) noexcept;
# 938 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/charconv" 3
}

#pragma GCC diagnostic pop
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 2 3







# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/monostate.h" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/monostate.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/monostate.h" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{

  struct monostate { };

  constexpr bool operator==(monostate, monostate) noexcept { return true; }

  constexpr strong_ordering
  operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; }
# 59 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/monostate.h" 3
  template<>
    struct hash<monostate>
    {





      size_t
      operator()(const monostate&) const noexcept
      {
 constexpr size_t __magic_monostate_hash = -7777;
 return __magic_monostate_hash;
      }
    };


}
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/formatfwd.h" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/formatfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Out, typename _CharT> class basic_format_context;


  template<typename _CharT> class basic_format_parse_context;


  template<typename _Tp, typename _CharT = char> struct formatter;


namespace __format
{

  template<typename _CharT>
    concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>;





  template<typename _Tp, typename _Context,
    typename _Formatter
      = typename _Context::template formatter_type<remove_const_t<_Tp>>,
    typename _ParseContext
      = basic_format_parse_context<typename _Context::char_type>>
    concept __parsable_with
      = semiregular<_Formatter>
   && requires (_Formatter __f, _ParseContext __pc)
    {
      { __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
    };

  template<typename _Tp, typename _Context,
    typename _Formatter
      = typename _Context::template formatter_type<remove_const_t<_Tp>>,
    typename _ParseContext
      = basic_format_parse_context<typename _Context::char_type>>
    concept __formattable_with
      = semiregular<_Formatter>
   && requires (const _Formatter __cf, _Tp&& __t, _Context __fc)
    {
      { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
    };


  template<typename _CharT>
    struct _Iter_for;
  template<typename _CharT>
    using _Iter_for_t = typename _Iter_for<_CharT>::type;

  template<typename _Tp, typename _CharT,
    typename _Context = basic_format_context<_Iter_for_t<_CharT>, _CharT>>
    concept __formattable_impl
      = __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;

  template<typename _Formatter>
    concept __has_debug_format = requires(_Formatter __f)
    {
      __f.set_debug_format();
    };

  template<__char _CharT>
    struct __formatter_int;
}
# 146 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/formatfwd.h" 3
}
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode.h" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __unicode
{

  constexpr bool
  __is_scalar_value(char32_t __c)
  {
    if (__c < 0xD800) [[likely]]
      return true;
    return 0xDFFF < __c && __c <= 0x10FFFF;
  }


  template<typename _CharT>
    constexpr bool
    __is_single_code_unit(char32_t __c)
    {
      if constexpr (__gnu_cxx::__int_traits<_CharT>::__max <= 0xFF)
 return __c < 0x7F;
      else
 return __c < __gnu_cxx::__int_traits<_CharT>::__max
         && __is_scalar_value(__c);
    }



  struct _Repl
  {
    constexpr char32_t
    operator()() const noexcept
    { return 0xFFFD; }
  };

  struct _Null_sentinel_t
  {
    template<input_iterator _It>
      requires default_initializable<iter_value_t<_It>>
 && equality_comparable_with<iter_reference_t<_It>, iter_value_t<_It>>
      friend constexpr auto
      operator==(_It __it, _Null_sentinel_t)
      { return *__it == iter_value_t<_It>{}; }
  };

  template<typename _FromFmt, typename _ToFmt,
    input_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
    typename _ErrorHandler = _Repl>
    requires convertible_to<iter_value_t<_Iter>, _FromFmt>
    class _Utf_iterator
    {
      static_assert(forward_iterator<_Iter> || noexcept(_ErrorHandler()()));

    public:
      using value_type = _ToFmt;
      using difference_type = iter_difference_t<_Iter>;
      using reference = value_type;
      using iterator_concept
 = std::__detail::__clamp_iter_cat<__iter_category_t<_Iter>,
       bidirectional_iterator_tag>;

      constexpr _Utf_iterator() = default;

      constexpr
      _Utf_iterator(_Iter __first, _Iter __it, _Sent __last)
      requires bidirectional_iterator<_Iter>
      : _M_first_and_curr{__first, __it}, _M_last(__last)
      {
 if (_M_curr() != _M_last)
   _M_read();
 else
   _M_buf = {};
      }

      constexpr
      _Utf_iterator(_Iter __it, _Sent __last)
      requires (!bidirectional_iterator<_Iter>)
      : _M_first_and_curr{__it}, _M_last(__last)
      {
 if (_M_curr() != _M_last)
   _M_read();
 else
   _M_buf = {};
      }

      template<class _Iter2, class _Sent2>
 requires convertible_to<_Iter2, _Iter> && convertible_to<_Sent2, _Sent>
 constexpr
 _Utf_iterator(const _Utf_iterator<_FromFmt, _ToFmt, _Iter2, _Sent2,
       _ErrorHandler>& __other)
 : _M_buf(__other._M_buf), _M_first_and_curr(__other._M_first_and_curr),
   _M_buf_index(__other._M_buf_index), _M_buf_last(__other._M_buf_last),
   _M_last(__other._M_last)
 { }

      [[nodiscard]]
      constexpr _Iter
      begin() const requires bidirectional_iterator<_Iter>
      { return _M_first(); }

      [[nodiscard]]
      constexpr _Sent
      end() const { return _M_last; }

      [[nodiscard]]
      constexpr _Iter
      base() const requires forward_iterator<_Iter>
      { return _M_curr(); }

      [[nodiscard]]
      constexpr iter_difference_t<_Iter>
      _M_units() const requires forward_iterator<_Iter>
      { return _M_to_increment; }

      [[nodiscard]]
      constexpr value_type
      operator*() const { return _M_buf[_M_buf_index]; }

      constexpr _Utf_iterator&
      operator++()
      {
 if (_M_buf_index + 1 == _M_buf_last && _M_curr() != _M_last)
   {
     if constexpr (forward_iterator<_Iter>)
       std::advance(_M_curr(), _M_to_increment);
     if (_M_curr() == _M_last)
       _M_buf_index = 0;
     else
       _M_read();
   }
 else if (_M_buf_index + 1 < _M_buf_last)
   ++_M_buf_index;
 return *this;
      }

      constexpr _Utf_iterator
      operator++(int)
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr _Utf_iterator&
      operator--() requires bidirectional_iterator<_Iter>
      {
 if (!_M_buf_index && _M_curr() != _M_first())
   _M_read_reverse();
 else if (_M_buf_index)
   --_M_buf_index;
 return *this;
      }

      constexpr _Utf_iterator
      operator--(int)
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      [[nodiscard]]
      friend constexpr bool
      operator==(_Utf_iterator __lhs, _Utf_iterator __rhs)
      requires forward_iterator<_Iter> || requires (_Iter __i) { __i != __i; }
      {
 if constexpr (forward_iterator<_Iter>)
   return __lhs._M_curr() == __rhs._M_curr()
     && __lhs._M_buf_index == __rhs._M_buf_index;
 else if (__lhs._M_curr() != __rhs._M_curr())
   return false;
 else if (__lhs._M_buf_index == __rhs._M_buf_index
     && __lhs._M_buf_last == __rhs._M_buf_last)
   return true;
 else
   return __lhs._M_buf_index == __lhs._M_buf_last
     && __rhs._M_buf_index == __rhs._M_buf_last;
      }

      [[nodiscard]]
      friend constexpr bool
      operator==(_Utf_iterator __lhs, _Sent __rhs)
      {
 if constexpr (forward_iterator<_Iter>)
   return __lhs._M_curr() == __rhs;
 else
   return __lhs._M_curr() == __rhs
     && __lhs._M_buf_index == __lhs._M_buf_last;
      }

    private:
      constexpr void
      _M_read()
      {
 if constexpr (sizeof(_FromFmt) == sizeof(uint8_t))
   _M_read_utf8();
 else if constexpr (sizeof(_FromFmt) == sizeof(uint16_t))
   _M_read_utf16();
 else
   {
     static_assert(sizeof(_FromFmt) == sizeof(uint32_t));
     _M_read_utf32();
   }
      }

      constexpr void
      _M_read_reverse();

      template<typename>
 struct _Guard
 {
   _Guard(void*, _Iter&) { }
 };

      template<typename _It> requires forward_iterator<_It>
 struct _Guard<_It>
 {
   constexpr ~_Guard() { _M_this->_M_curr() = std::move(_M_orig); }
   _Utf_iterator* _M_this;
   _It _M_orig;
 };

      constexpr void
      _M_read_utf8()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c{};
 const uint8_t __lo_bound = 0x80, __hi_bound = 0xBF;
 uint8_t __u = *_M_curr()++;
 uint8_t __to_incr = 1;
 auto __incr = [&, this] {
   ++__to_incr;
   return ++_M_curr();
 };

 if (__u <= 0x7F) [[likely]]
   __c = __u;
 else if (__u < 0xC2) [[unlikely]]
   __c = _S_error();
 else if (_M_curr() == _M_last) [[unlikely]]
   __c = _S_error();
 else if (__u <= 0xDF)
   {
     __c = __u & 0x1F;
     __u = *_M_curr();

     if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __incr();
       }
   }
 else if (__u <= 0xEF)
   {
     const uint8_t __lo_bound_2 = __u == 0xE0 ? 0xA0 : __lo_bound;
     const uint8_t __hi_bound_2 = __u == 0xED ? 0x9F : __hi_bound;

     __c = __u & 0x0F;
     __u = *_M_curr();

     if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
       __c = _S_error();
     else if (__incr() == _M_last) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __u = *_M_curr();

  if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
    __c = _S_error();
  else
    {
      __c = (__c << 6) | (__u & 0x3F);
      __incr();
    }
       }
   }
 else if (__u <= 0xF4)
   {
     const uint8_t __lo_bound_2 = __u == 0xF0 ? 0x90 : __lo_bound;
     const uint8_t __hi_bound_2 = __u == 0xF4 ? 0x8F : __hi_bound;

     __c = __u & 0x07;
     __u = *_M_curr();

     if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
       __c = _S_error();
     else if (__incr() == _M_last) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __u = *_M_curr();

  if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
    __c = _S_error();
  else if (__incr() == _M_last) [[unlikely]]
    __c = _S_error();
  else
    {
      __c = (__c << 6) | (__u & 0x3F);
      __u = *_M_curr();

      if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
        __c = _S_error();
      else
        {
   __c = (__c << 6) | (__u & 0x3F);
   __incr();
        }
    }
       }
   }
 else [[unlikely]]
   __c = _S_error();

 _M_update(__c, __to_incr);
      }

      constexpr void
      _M_read_utf16()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c{};
 uint16_t __u = *_M_curr()++;
 uint8_t __to_incr = 1;

 if (__u < 0xD800 || __u > 0xDFFF) [[likely]]
   __c = __u;
 else if (__u < 0xDC00 && _M_curr() != _M_last)
   {
     uint16_t __u2 = *_M_curr();
     if (__u2 < 0xDC00 || __u2 > 0xDFFF) [[unlikely]]
       __c = _S_error();
     else
       {
  ++_M_curr();
  __to_incr = 2;
  uint32_t __x = (__u & 0x3F) << 10 | (__u2 & 0x3FF);
  uint32_t __w = (__u >> 6) & 0x1F;
  __c = (__w + 1) << 16 | __x;
       }
   }
 else
   __c = _S_error();

 _M_update(__c, __to_incr);
      }

      constexpr void
      _M_read_utf32()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c = *_M_curr()++;
 if (!__is_scalar_value(__c)) [[unlikely]]
   __c = _S_error();
 _M_update(__c, 1);
      }


      constexpr void
      _M_update(char32_t __c, uint8_t __to_incr)
      {
 _M_to_increment = __to_incr;
 _M_buf_index = 0;
 if constexpr (sizeof(_ToFmt) == sizeof(uint32_t))
   {
     _M_buf[0] = __c;
     _M_buf_last = 1;
   }
 else if constexpr (sizeof(_ToFmt) == sizeof(uint16_t))
   {
     if (__is_single_code_unit<_ToFmt>(__c))
       {
  _M_buf[0] = __c;
  _M_buf[1] = 0;
  _M_buf_last = 1;
       }
     else
       {

  const char32_t __lead_offset = 0xD800 - (0x10000 >> 10);
  char16_t __lead = __lead_offset + (__c >> 10);
  char16_t __trail = 0xDC00 + (__c & 0x3FF);
  _M_buf[0] = __lead;
  _M_buf[1] = __trail;
  _M_buf_last = 2;
       }
   }
 else
   {
     static_assert(sizeof(_ToFmt) == 1);
     int __bits = std::bit_width((uint32_t)__c);
     if (__bits <= 7) [[likely]]
       {
  _M_buf[0] = __c;
  _M_buf[1] = _M_buf[2] = _M_buf[3] = 0;
  _M_buf_last = 1;
       }
     else if (__bits <= 11)
       {
  _M_buf[0] = 0xC0 | (__c >> 6);
  _M_buf[1] = 0x80 | (__c & 0x3F);
  _M_buf[2] = _M_buf[3] = 0;
  _M_buf_last = 2;
       }
     else if (__bits <= 16)
       {
  _M_buf[0] = 0xE0 | (__c >> 12);
  _M_buf[1] = 0x80 | ((__c >> 6) & 0x3F);
  _M_buf[2] = 0x80 | (__c & 0x3F);
  _M_buf[3] = 0;
  _M_buf_last = 3;
       }
     else
       {
  _M_buf[0] = 0xF0 | ((__c >> 18) & 0x07);
  _M_buf[1] = 0x80 | ((__c >> 12) & 0x3F);
  _M_buf[2] = 0x80 | ((__c >> 6) & 0x3F);
  _M_buf[3] = 0x80 | (__c & 0x3F);
  _M_buf_last = 4;
       }
   }
      }

      constexpr char32_t
      _S_error()
      {
 char32_t __c = _ErrorHandler()();
 do { if (std::__is_constant_evaluated() && !bool(__is_scalar_value(__c))) std::__glibcxx_assert_fail(); } while (false);
 return __c;
      }

      constexpr _Iter
      _M_first() const requires bidirectional_iterator<_Iter>
      { return _M_first_and_curr._M_first; }

      constexpr _Iter&
      _M_curr() { return _M_first_and_curr._M_curr; }

      constexpr _Iter
      _M_curr() const { return _M_first_and_curr._M_curr; }

      array<value_type, 4 / sizeof(_ToFmt)> _M_buf;

      template<typename _It>
 struct _First_and_curr
 {
   _First_and_curr() = default;

   constexpr
   _First_and_curr(_It __curr) : _M_curr(__curr) { }

   template<convertible_to<_It> _It2>
     constexpr
     _First_and_curr(const _First_and_curr<_It2>& __other)
     : _M_curr(__other._M_curr) { }

   _It _M_curr;
 };

      template<typename _It> requires bidirectional_iterator<_It>
 struct _First_and_curr<_It>
 {
   _First_and_curr() = default;

   constexpr
   _First_and_curr(_It __first, _It __curr)
   : _M_first(__first), _M_curr(__curr) { }

   template<convertible_to<_It> _It2>
     constexpr
     _First_and_curr(const _First_and_curr<_It2>& __other)
     : _M_first(__other._M_first), _M_curr(__other._M_curr) { }

   _It _M_first;
   _It _M_curr;
 };

      _First_and_curr<_Iter> _M_first_and_curr;

      uint8_t _M_buf_index = 0;
      uint8_t _M_buf_last = 0;
      uint8_t _M_to_increment = 0;

      [[no_unique_address]] _Sent _M_last;

      template<typename _FromFmt2, typename _ToFmt2,
        input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
        typename _ErrHandler>
 requires convertible_to<iter_value_t<_Iter2>, _FromFmt2>
 friend class _Utf_iterator;
    };

  template<typename _ToFormat, ranges::input_range _Range>
    class _Utf_view
    : public ranges::view_interface<_Utf_view<_ToFormat, _Range>>
    {
      using _Iterator = _Utf_iterator<ranges::range_value_t<_Range>,
          _ToFormat, ranges::iterator_t<_Range>,
          ranges::sentinel_t<_Range>>;

      template<typename _Iter, typename _Sent>
 constexpr auto
 _M_begin(_Iter __first, _Sent __last)
 {
   if constexpr (bidirectional_iterator<_Iter>)
     return _Iterator(__first, __first, __last);
   else
     return _Iterator(__first, __last);
 }

      template<typename _Iter, typename _Sent>
 constexpr auto
 _M_end(_Iter __first, _Sent __last)
 {
   if constexpr (!is_same_v<_Iter, _Sent>)
     return __last;
   else if constexpr (bidirectional_iterator<_Iter>)
     return _Iterator(__first, __last, __last);
   else
     return _Iterator(__last, __last);
 }

      _Range _M_base;

    public:
      constexpr explicit
      _Utf_view(_Range&& __r) : _M_base(std::forward<_Range>(__r)) { }

      constexpr auto begin()
      { return _M_begin(ranges::begin(_M_base), ranges::end(_M_base)); }

      constexpr auto end()
      { return _M_end(ranges::begin(_M_base), ranges::end(_M_base)); }

      constexpr bool empty() const { return ranges::empty(_M_base); }
    };


  template<typename _View>
    using _Utf8_view = _Utf_view<char8_t, _View>;




  template<typename _View>
    using _Utf16_view = _Utf_view<char16_t, _View>;
  template<typename _View>
    using _Utf32_view = _Utf_view<char32_t, _View>;

inline namespace __v16_0_0
{

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode-data.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode-data.h" 3
  inline constexpr char32_t __width_edges[] = {
    0x1100, 0x1160, 0x231a, 0x231c, 0x2329, 0x232b, 0x23e9, 0x23ed,
    0x23f0, 0x23f1, 0x23f3, 0x23f4, 0x25fd, 0x25ff, 0x2614, 0x2616,
    0x2630, 0x2638, 0x2648, 0x2654, 0x267f, 0x2680, 0x268a, 0x2690,
    0x2693, 0x2694, 0x26a1, 0x26a2, 0x26aa, 0x26ac, 0x26bd, 0x26bf,
    0x26c4, 0x26c6, 0x26ce, 0x26cf, 0x26d4, 0x26d5, 0x26ea, 0x26eb,
    0x26f2, 0x26f4, 0x26f5, 0x26f6, 0x26fa, 0x26fb, 0x26fd, 0x26fe,
    0x2705, 0x2706, 0x270a, 0x270c, 0x2728, 0x2729, 0x274c, 0x274d,
    0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758, 0x2795, 0x2798,
    0x27b0, 0x27b1, 0x27bf, 0x27c0, 0x2b1b, 0x2b1d, 0x2b50, 0x2b51,
    0x2b55, 0x2b56, 0x2e80, 0x2e9a, 0x2e9b, 0x2ef4, 0x2f00, 0x2fd6,
    0x2ff0, 0x303f, 0x3041, 0x3097, 0x3099, 0x3100, 0x3105, 0x3130,
    0x3131, 0x318f, 0x3190, 0x31e6, 0x31ef, 0x321f, 0x3220, 0x3248,
    0x3250, 0xa48d, 0xa490, 0xa4c7, 0xa960, 0xa97d, 0xac00, 0xd7a4,
    0xf900, 0xfb00, 0xfe10, 0xfe1a, 0xfe30, 0xfe53, 0xfe54, 0xfe67,
    0xfe68, 0xfe6c, 0xff01, 0xff61, 0xffe0, 0xffe7, 0x16fe0, 0x16fe5,
    0x16ff0, 0x16ff2, 0x17000, 0x187f8, 0x18800, 0x18cd6, 0x18cff, 0x18d09,
    0x1aff0, 0x1aff4, 0x1aff5, 0x1affc, 0x1affd, 0x1afff, 0x1b000, 0x1b123,
    0x1b132, 0x1b133, 0x1b150, 0x1b153, 0x1b155, 0x1b156, 0x1b164, 0x1b168,
    0x1b170, 0x1b2fc, 0x1d300, 0x1d357, 0x1d360, 0x1d377, 0x1f004, 0x1f005,
    0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f200, 0x1f203,
    0x1f210, 0x1f23c, 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266,
    0x1f300, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3,
    0x1f6d5, 0x1f6d8, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd,
    0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00, 0x1fa70, 0x1fa7d,
    0x1fa80, 0x1fa8a, 0x1fa8f, 0x1fac7, 0x1face, 0x1fadd, 0x1fadf, 0x1faea,
    0x1faf0, 0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe,
  };




  inline constexpr uint32_t __escape_edges[] = {
    0x1, 0x42, 0xff, 0x142, 0x15b, 0x15c,
    0x6f1, 0x6f4, 0x701, 0x708, 0x717, 0x718,
    0x71b, 0x71c, 0x745, 0x746, 0xa61, 0xa62,
    0xaaf, 0xab2, 0xb17, 0xb1a, 0xb21, 0xb22,
    0xb91, 0xba0, 0xbd7, 0xbde, 0xbeb, 0xc0c,
    0xc39, 0xc3a, 0xdbb, 0xdbc, 0xe1d, 0xe20,
    0xe97, 0xe9a, 0xf65, 0xf80, 0xff7, 0xffa,
    0x105d, 0x1060, 0x107f, 0x1080, 0x10b9, 0x10bc,
    0x10bf, 0x10c0, 0x10d7, 0x10e0, 0x111f, 0x112e,
    0x11c5, 0x11c6, 0x1309, 0x130a, 0x131b, 0x131e,
    0x1323, 0x1326, 0x1353, 0x1354, 0x1363, 0x1364,
    0x1367, 0x136c, 0x1375, 0x1378, 0x138b, 0x138e,
    0x1393, 0x1396, 0x139f, 0x13ae, 0x13b1, 0x13b8,
    0x13bd, 0x13be, 0x13c9, 0x13cc, 0x13ff, 0x1402,
    0x1409, 0x140a, 0x1417, 0x141e, 0x1423, 0x1426,
    0x1453, 0x1454, 0x1463, 0x1464, 0x1469, 0x146a,
    0x146f, 0x1470, 0x1475, 0x1478, 0x147b, 0x147c,
    0x1487, 0x148e, 0x1493, 0x1496, 0x149d, 0x14a2,
    0x14a5, 0x14b2, 0x14bb, 0x14bc, 0x14bf, 0x14cc,
    0x14ef, 0x1502, 0x1509, 0x150a, 0x151d, 0x151e,
    0x1525, 0x1526, 0x1553, 0x1554, 0x1563, 0x1564,
    0x1569, 0x156a, 0x1575, 0x1578, 0x158d, 0x158e,
    0x1595, 0x1596, 0x159d, 0x15a0, 0x15a3, 0x15c0,
    0x15c9, 0x15cc, 0x15e5, 0x15f2, 0x1601, 0x1602,
    0x1609, 0x160a, 0x161b, 0x161e, 0x1623, 0x1626,
    0x1653, 0x1654, 0x1663, 0x1664, 0x1669, 0x166a,
    0x1675, 0x1678, 0x168b, 0x168e, 0x1693, 0x1696,
    0x169d, 0x16aa, 0x16b1, 0x16b8, 0x16bd, 0x16be,
    0x16c9, 0x16cc, 0x16f1, 0x1704, 0x1709, 0x170a,
    0x1717, 0x171c, 0x1723, 0x1724, 0x172d, 0x1732,
    0x1737, 0x1738, 0x173b, 0x173c, 0x1741, 0x1746,
    0x174b, 0x1750, 0x1757, 0x175c, 0x1775, 0x177c,
    0x1787, 0x178c, 0x1793, 0x1794, 0x179d, 0x17a0,
    0x17a3, 0x17ae, 0x17b1, 0x17cc, 0x17f7, 0x1800,
    0x181b, 0x181c, 0x1823, 0x1824, 0x1853, 0x1854,
    0x1875, 0x1878, 0x188b, 0x188c, 0x1893, 0x1894,
    0x189d, 0x18aa, 0x18af, 0x18b0, 0x18b7, 0x18ba,
    0x18bd, 0x18c0, 0x18c9, 0x18cc, 0x18e1, 0x18ee,
    0x191b, 0x191c, 0x1923, 0x1924, 0x1953, 0x1954,
    0x1969, 0x196a, 0x1975, 0x1978, 0x198b, 0x198c,
    0x1993, 0x1994, 0x199d, 0x19aa, 0x19af, 0x19ba,
    0x19bf, 0x19c0, 0x19c9, 0x19cc, 0x19e1, 0x19e2,
    0x19e9, 0x1a00, 0x1a1b, 0x1a1c, 0x1a23, 0x1a24,
    0x1a8b, 0x1a8c, 0x1a93, 0x1a94, 0x1aa1, 0x1aa8,
    0x1ac9, 0x1acc, 0x1b01, 0x1b02, 0x1b09, 0x1b0a,
    0x1b2f, 0x1b34, 0x1b65, 0x1b66, 0x1b79, 0x1b7a,
    0x1b7d, 0x1b80, 0x1b8f, 0x1b94, 0x1b97, 0x1b9e,
    0x1bab, 0x1bac, 0x1baf, 0x1bb0, 0x1bc1, 0x1bcc,
    0x1be1, 0x1be4, 0x1beb, 0x1c02, 0x1c77, 0x1c7e,
    0x1cb9, 0x1d02, 0x1d07, 0x1d08, 0x1d0b, 0x1d0c,
    0x1d17, 0x1d18, 0x1d49, 0x1d4a, 0x1d4d, 0x1d4e,
    0x1d7d, 0x1d80, 0x1d8b, 0x1d8c, 0x1d8f, 0x1d90,
    0x1d9f, 0x1da0, 0x1db5, 0x1db8, 0x1dc1, 0x1e00,
    0x1e91, 0x1e92, 0x1edb, 0x1ee2, 0x1f31, 0x1f32,
    0x1f7b, 0x1f7c, 0x1f9b, 0x1f9c, 0x1fb7, 0x2000,
    0x218d, 0x218e, 0x2191, 0x219a, 0x219d, 0x21a0,
    0x2493, 0x2494, 0x249d, 0x24a0, 0x24af, 0x24b0,
    0x24b3, 0x24b4, 0x24bd, 0x24c0, 0x2513, 0x2514,
    0x251d, 0x2520, 0x2563, 0x2564, 0x256d, 0x2570,
    0x257f, 0x2580, 0x2583, 0x2584, 0x258d, 0x2590,
    0x25af, 0x25b0, 0x2623, 0x2624, 0x262d, 0x2630,
    0x26b7, 0x26ba, 0x26fb, 0x2700, 0x2735, 0x2740,
    0x27ed, 0x27f0, 0x27fd, 0x2800, 0x2d01, 0x2d02,
    0x2d3b, 0x2d40, 0x2df3, 0x2e00, 0x2e2d, 0x2e3e,
    0x2e6f, 0x2e80, 0x2ea9, 0x2ec0, 0x2edb, 0x2edc,
    0x2ee3, 0x2ee4, 0x2ee9, 0x2f00, 0x2fbd, 0x2fc0,
    0x2fd5, 0x2fe0, 0x2ff5, 0x3000, 0x301d, 0x301e,
    0x3035, 0x3040, 0x30f3, 0x3100, 0x3157, 0x3160,
    0x31ed, 0x3200, 0x323f, 0x3240, 0x3259, 0x3260,
    0x3279, 0x3280, 0x3283, 0x3288, 0x32dd, 0x32e0,
    0x32eb, 0x3300, 0x3359, 0x3360, 0x3395, 0x33a0,
    0x33b7, 0x33bc, 0x3439, 0x343c, 0x34bf, 0x34c0,
    0x34fb, 0x34fe, 0x3515, 0x3520, 0x3535, 0x3540,
    0x355d, 0x3560, 0x359f, 0x3600, 0x369b, 0x369c,
    0x37e9, 0x37f8, 0x3871, 0x3876, 0x3895, 0x389a,
    0x3917, 0x3920, 0x3977, 0x397a, 0x3991, 0x39a0,
    0x39f7, 0x3a00, 0x3e2d, 0x3e30, 0x3e3d, 0x3e40,
    0x3e8d, 0x3e90, 0x3e9d, 0x3ea0, 0x3eb1, 0x3eb2,
    0x3eb5, 0x3eb6, 0x3eb9, 0x3eba, 0x3ebd, 0x3ebe,
    0x3efd, 0x3f00, 0x3f6b, 0x3f6c, 0x3f8b, 0x3f8c,
    0x3fa9, 0x3fac, 0x3fb9, 0x3fba, 0x3fe1, 0x3fe4,
    0x3feb, 0x3fec, 0x3fff, 0x4020, 0x4051, 0x4060,
    0x40bf, 0x40e0, 0x40e5, 0x40e8, 0x411f, 0x4120,
    0x413b, 0x4140, 0x4183, 0x41a0, 0x41e3, 0x4200,
    0x4319, 0x4320, 0x4855, 0x4880, 0x4897, 0x48c0,
    0x56e9, 0x56ec, 0x572d, 0x572e, 0x59e9, 0x59f2,
    0x5a4d, 0x5a4e, 0x5a51, 0x5a5a, 0x5a5d, 0x5a60,
    0x5ad1, 0x5ade, 0x5ae3, 0x5afe, 0x5b2f, 0x5b40,
    0x5b4f, 0x5b50, 0x5b5f, 0x5b60, 0x5b6f, 0x5b70,
    0x5b7f, 0x5b80, 0x5b8f, 0x5b90, 0x5b9f, 0x5ba0,
    0x5baf, 0x5bb0, 0x5bbf, 0x5bc0, 0x5cbd, 0x5d00,
    0x5d35, 0x5d36, 0x5de9, 0x5e00, 0x5fad, 0x5fe0,
    0x6001, 0x6002, 0x6081, 0x6082, 0x612f, 0x6132,
    0x6201, 0x620a, 0x6261, 0x6262, 0x631f, 0x6320,
    0x63cd, 0x63de, 0x643f, 0x6440, 0x1491b, 0x14920,
    0x1498f, 0x149a0, 0x14c59, 0x14c80, 0x14df1, 0x14e00,
    0x14f9d, 0x14fa0, 0x14fa5, 0x14fa6, 0x14fa9, 0x14faa,
    0x14fbb, 0x14fe4, 0x1505b, 0x15060, 0x15075, 0x15080,
    0x150f1, 0x15100, 0x1518d, 0x1519c, 0x151b5, 0x151c0,
    0x152a9, 0x152be, 0x152fb, 0x15300, 0x1539d, 0x1539e,
    0x153b5, 0x153bc, 0x153ff, 0x15400, 0x1546f, 0x15480,
    0x1549d, 0x154a0, 0x154b5, 0x154b8, 0x15587, 0x155b6,
    0x155ef, 0x15602, 0x1560f, 0x15612, 0x1561f, 0x15622,
    0x1562f, 0x15640, 0x1564f, 0x15650, 0x1565f, 0x15660,
    0x156d9, 0x156e0, 0x157dd, 0x157e0, 0x157f5, 0x15800,
    0x1af49, 0x1af60, 0x1af8f, 0x1af96, 0x1aff9, 0x1f200,
    0x1f4dd, 0x1f4e0, 0x1f5b5, 0x1f600, 0x1f60f, 0x1f626,
    0x1f631, 0x1f63a, 0x1f66f, 0x1f670, 0x1f67b, 0x1f67c,
    0x1f67f, 0x1f680, 0x1f685, 0x1f686, 0x1f68b, 0x1f68c,
    0x1f787, 0x1f7a6, 0x1fb21, 0x1fb24, 0x1fb91, 0x1fb9e,
    0x1fba1, 0x1fbe0, 0x1fc35, 0x1fc40, 0x1fca7, 0x1fca8,
    0x1fccf, 0x1fcd0, 0x1fcd9, 0x1fce0, 0x1fceb, 0x1fcec,
    0x1fdfb, 0x1fe02, 0x1ff7f, 0x1ff84, 0x1ff91, 0x1ff94,
    0x1ffa1, 0x1ffa4, 0x1ffb1, 0x1ffb4, 0x1ffbb, 0x1ffc0,
    0x1ffcf, 0x1ffd0, 0x1ffdf, 0x1fff8, 0x1fffd, 0x20000,
    0x20019, 0x2001a, 0x2004f, 0x20050, 0x20077, 0x20078,
    0x2007d, 0x2007e, 0x2009d, 0x200a0, 0x200bd, 0x20100,
    0x201f7, 0x20200, 0x20207, 0x2020e, 0x20269, 0x2026e,
    0x2031f, 0x20320, 0x2033b, 0x20340, 0x20343, 0x203a0,
    0x203fd, 0x20500, 0x2053b, 0x20540, 0x205a3, 0x205c0,
    0x205f9, 0x20600, 0x20649, 0x2065a, 0x20697, 0x206a0,
    0x206f7, 0x20700, 0x2073d, 0x2073e, 0x20789, 0x20790,
    0x207ad, 0x20800, 0x2093d, 0x20940, 0x20955, 0x20960,
    0x209a9, 0x209b0, 0x209f9, 0x20a00, 0x20a51, 0x20a60,
    0x20ac9, 0x20ade, 0x20af7, 0x20af8, 0x20b17, 0x20b18,
    0x20b27, 0x20b28, 0x20b2d, 0x20b2e, 0x20b45, 0x20b46,
    0x20b65, 0x20b66, 0x20b75, 0x20b76, 0x20b7b, 0x20b80,
    0x20be9, 0x20c00, 0x20e6f, 0x20e80, 0x20ead, 0x20ec0,
    0x20ed1, 0x20f00, 0x20f0d, 0x20f0e, 0x20f63, 0x20f64,
    0x20f77, 0x21000, 0x2100d, 0x21010, 0x21013, 0x21014,
    0x2106d, 0x2106e, 0x21073, 0x21078, 0x2107b, 0x2107e,
    0x210ad, 0x210ae, 0x2113f, 0x2114e, 0x21161, 0x211c0,
    0x211e7, 0x211e8, 0x211ed, 0x211f6, 0x21239, 0x2123e,
    0x21275, 0x2127e, 0x21281, 0x21300, 0x21371, 0x21378,
    0x213a1, 0x213a4, 0x21409, 0x2140a, 0x2140f, 0x21418,
    0x21429, 0x2142a, 0x21431, 0x21432, 0x2146d, 0x21470,
    0x21477, 0x2147e, 0x21493, 0x214a0, 0x214b3, 0x214c0,
    0x21541, 0x21580, 0x215cf, 0x215d6, 0x215ef, 0x21600,
    0x2166d, 0x21672, 0x216ad, 0x216b0, 0x216e7, 0x216f0,
    0x21725, 0x21732, 0x2173b, 0x21752, 0x21761, 0x21800,
    0x21893, 0x21900, 0x21967, 0x21980, 0x219e7, 0x219f4,
    0x21a51, 0x21a60, 0x21a75, 0x21a80, 0x21acd, 0x21ad2,
    0x21b0d, 0x21b1c, 0x21b21, 0x21cc0, 0x21cff, 0x21d00,
    0x21d55, 0x21d56, 0x21d5d, 0x21d60, 0x21d65, 0x21d84,
    0x21d8b, 0x21df8, 0x21e51, 0x21e60, 0x21eb5, 0x21ee0,
    0x21f15, 0x21f60, 0x21f99, 0x21fc0, 0x21fef, 0x22000,
    0x2209d, 0x220a4, 0x220ed, 0x220fe, 0x2217b, 0x2217c,
    0x22187, 0x221a0, 0x221d3, 0x221e0, 0x221f5, 0x22200,
    0x2226b, 0x2226c, 0x22291, 0x222a0, 0x222ef, 0x22300,
    0x223c1, 0x223c2, 0x223eb, 0x22400, 0x22425, 0x22426,
    0x22485, 0x22500, 0x2250f, 0x22510, 0x22513, 0x22514,
    0x2251d, 0x2251e, 0x2253d, 0x2253e, 0x22555, 0x22560,
    0x225d7, 0x225e0, 0x225f5, 0x22600, 0x22609, 0x2260a,
    0x2261b, 0x2261e, 0x22623, 0x22626, 0x22653, 0x22654,
    0x22663, 0x22664, 0x22669, 0x2266a, 0x22675, 0x22676,
    0x2268b, 0x2268e, 0x22693, 0x22696, 0x2269d, 0x226a0,
    0x226a3, 0x226ae, 0x226b1, 0x226ba, 0x226c9, 0x226cc,
    0x226db, 0x226e0, 0x226eb, 0x22700, 0x22715, 0x22716,
    0x22719, 0x2271c, 0x2271f, 0x22720, 0x2276d, 0x2276e,
    0x22783, 0x22784, 0x22787, 0x2278a, 0x2278d, 0x2278e,
    0x22797, 0x22798, 0x227ad, 0x227ae, 0x227b3, 0x227c2,
    0x227c7, 0x22800, 0x228b9, 0x228ba, 0x228c5, 0x22900,
    0x22991, 0x229a0, 0x229b5, 0x22b00, 0x22b6d, 0x22b70,
    0x22bbd, 0x22c00, 0x22c8b, 0x22ca0, 0x22cb5, 0x22cc0,
    0x22cdb, 0x22d00, 0x22d75, 0x22d80, 0x22d95, 0x22da0,
    0x22dc9, 0x22e00, 0x22e37, 0x22e3a, 0x22e59, 0x22e60,
    0x22e8f, 0x23000, 0x23079, 0x23140, 0x231e7, 0x231fe,
    0x2320f, 0x23212, 0x23215, 0x23218, 0x23229, 0x2322a,
    0x2322f, 0x23230, 0x2326d, 0x2326e, 0x23273, 0x23276,
    0x2328f, 0x232a0, 0x232b5, 0x23340, 0x23351, 0x23354,
    0x233b1, 0x233b4, 0x233cb, 0x23400, 0x23491, 0x234a0,
    0x23547, 0x23560, 0x235f3, 0x23600, 0x23615, 0x23780,
    0x237c5, 0x237e0, 0x237f5, 0x23800, 0x23813, 0x23814,
    0x2386f, 0x23870, 0x2388d, 0x238a0, 0x238db, 0x238e0,
    0x23921, 0x23924, 0x23951, 0x23952, 0x2396f, 0x23a00,
    0x23a0f, 0x23a10, 0x23a15, 0x23a16, 0x23a6f, 0x23a74,
    0x23a77, 0x23a78, 0x23a7d, 0x23a7e, 0x23a91, 0x23aa0,
    0x23ab5, 0x23ac0, 0x23acd, 0x23ace, 0x23ad3, 0x23ad4,
    0x23b1f, 0x23b20, 0x23b25, 0x23b26, 0x23b33, 0x23b40,
    0x23b55, 0x23dc0, 0x23df3, 0x23e00, 0x23e23, 0x23e24,
    0x23e77, 0x23e7c, 0x23eb7, 0x23f60, 0x23f63, 0x23f80,
    0x23fe5, 0x23ffe, 0x24735, 0x24800, 0x248df, 0x248e0,
    0x248eb, 0x24900, 0x24a89, 0x25f20, 0x25fe7, 0x26000,
    0x26861, 0x26880, 0x268ad, 0x268c0, 0x287f7, 0x28800,
    0x28c8f, 0x2c200, 0x2c275, 0x2d000, 0x2d473, 0x2d480,
    0x2d4bf, 0x2d4c0, 0x2d4d5, 0x2d4dc, 0x2d57f, 0x2d580,
    0x2d595, 0x2d5a0, 0x2d5dd, 0x2d5e0, 0x2d5ed, 0x2d600,
    0x2d68d, 0x2d6a0, 0x2d6b5, 0x2d6b6, 0x2d6c5, 0x2d6c6,
    0x2d6f1, 0x2d6fa, 0x2d721, 0x2da80, 0x2daf5, 0x2dc80,
    0x2dd37, 0x2de00, 0x2de97, 0x2de9e, 0x2df11, 0x2df1e,
    0x2df41, 0x2dfc0, 0x2dfcb, 0x2dfe0, 0x2dfe5, 0x2e000,
    0x30ff1, 0x31000, 0x319ad, 0x319fe, 0x31a13, 0x35fe0,
    0x35fe9, 0x35fea, 0x35ff9, 0x35ffa, 0x35fff, 0x36000,
    0x36247, 0x36264, 0x36267, 0x362a0, 0x362a7, 0x362aa,
    0x362ad, 0x362c8, 0x362d1, 0x362e0, 0x365f9, 0x37800,
    0x378d7, 0x378e0, 0x378fb, 0x37900, 0x37913, 0x37920,
    0x37935, 0x37938, 0x37941, 0x39800, 0x399f5, 0x39a00,
    0x39d69, 0x39e00, 0x39e5d, 0x39e60, 0x39e8f, 0x39ea0,
    0x39f89, 0x3a000, 0x3a1ed, 0x3a200, 0x3a24f, 0x3a252,
    0x3a2e7, 0x3a2f6, 0x3a3d7, 0x3a400, 0x3a48d, 0x3a580,
    0x3a5a9, 0x3a5c0, 0x3a5e9, 0x3a600, 0x3a6af, 0x3a6c0,
    0x3a6f3, 0x3a800, 0x3a8ab, 0x3a8ac, 0x3a93b, 0x3a93c,
    0x3a941, 0x3a944, 0x3a947, 0x3a94a, 0x3a94f, 0x3a952,
    0x3a95b, 0x3a95c, 0x3a975, 0x3a976, 0x3a979, 0x3a97a,
    0x3a989, 0x3a98a, 0x3aa0d, 0x3aa0e, 0x3aa17, 0x3aa1a,
    0x3aa2b, 0x3aa2c, 0x3aa3b, 0x3aa3c, 0x3aa75, 0x3aa76,
    0x3aa7f, 0x3aa80, 0x3aa8b, 0x3aa8c, 0x3aa8f, 0x3aa94,
    0x3aaa3, 0x3aaa4, 0x3ad4d, 0x3ad50, 0x3af99, 0x3af9c,
    0x3b519, 0x3b536, 0x3b541, 0x3b542, 0x3b561, 0x3be00,
    0x3be3f, 0x3be4a, 0x3be57, 0x3c000, 0x3c00f, 0x3c010,
    0x3c033, 0x3c036, 0x3c045, 0x3c046, 0x3c04b, 0x3c04c,
    0x3c057, 0x3c060, 0x3c0dd, 0x3c11e, 0x3c121, 0x3c200,
    0x3c25b, 0x3c260, 0x3c27d, 0x3c280, 0x3c295, 0x3c29c,
    0x3c2a1, 0x3c520, 0x3c55f, 0x3c580, 0x3c5f5, 0x3c5fe,
    0x3c601, 0x3c9a0, 0x3c9f5, 0x3cba0, 0x3cbf7, 0x3cbfe,
    0x3cc01, 0x3cfc0, 0x3cfcf, 0x3cfd0, 0x3cfd9, 0x3cfda,
    0x3cfdf, 0x3cfe0, 0x3cfff, 0x3d000, 0x3d18b, 0x3d18e,
    0x3d1af, 0x3d200, 0x3d299, 0x3d2a0, 0x3d2b5, 0x3d2bc,
    0x3d2c1, 0x3d8e2, 0x3d96b, 0x3da02, 0x3da7d, 0x3dc00,
    0x3dc09, 0x3dc0a, 0x3dc41, 0x3dc42, 0x3dc47, 0x3dc48,
    0x3dc4b, 0x3dc4e, 0x3dc51, 0x3dc52, 0x3dc67, 0x3dc68,
    0x3dc71, 0x3dc72, 0x3dc75, 0x3dc76, 0x3dc79, 0x3dc84,
    0x3dc87, 0x3dc8e, 0x3dc91, 0x3dc92, 0x3dc95, 0x3dc96,
    0x3dc99, 0x3dc9a, 0x3dca1, 0x3dca2, 0x3dca7, 0x3dca8,
    0x3dcab, 0x3dcae, 0x3dcb1, 0x3dcb2, 0x3dcb5, 0x3dcb6,
    0x3dcb9, 0x3dcba, 0x3dcbd, 0x3dcbe, 0x3dcc1, 0x3dcc2,
    0x3dcc7, 0x3dcc8, 0x3dccb, 0x3dcce, 0x3dcd7, 0x3dcd8,
    0x3dce7, 0x3dce8, 0x3dcf1, 0x3dcf2, 0x3dcfb, 0x3dcfc,
    0x3dcff, 0x3dd00, 0x3dd15, 0x3dd16, 0x3dd39, 0x3dd42,
    0x3dd49, 0x3dd4a, 0x3dd55, 0x3dd56, 0x3dd79, 0x3dde0,
    0x3dde5, 0x3e000, 0x3e059, 0x3e060, 0x3e129, 0x3e140,
    0x3e15f, 0x3e162, 0x3e181, 0x3e182, 0x3e1a1, 0x3e1a2,
    0x3e1ed, 0x3e200, 0x3e35d, 0x3e3cc, 0x3e407, 0x3e420,
    0x3e479, 0x3e480, 0x3e493, 0x3e4a0, 0x3e4a5, 0x3e4c0,
    0x3e4cd, 0x3e600, 0x3edb1, 0x3edb8, 0x3eddb, 0x3ede0,
    0x3edfb, 0x3ee00, 0x3eeef, 0x3eef6, 0x3efb5, 0x3efc0,
    0x3efd9, 0x3efe0, 0x3efe3, 0x3f000, 0x3f019, 0x3f020,
    0x3f091, 0x3f0a0, 0x3f0b5, 0x3f0c0, 0x3f111, 0x3f120,
    0x3f15d, 0x3f160, 0x3f179, 0x3f180, 0x3f185, 0x3f200,
    0x3f4a9, 0x3f4c0, 0x3f4dd, 0x3f4e0, 0x3f4fb, 0x3f500,
    0x3f515, 0x3f51e, 0x3f58f, 0x3f59c, 0x3f5bb, 0x3f5be,
    0x3f5d5, 0x3f5e0, 0x3f5f3, 0x3f600, 0x3f727, 0x3f728,
    0x3f7f5, 0x40000, 0x54dc1, 0x54e00, 0x56e75, 0x56e80,
    0x5703d, 0x57040, 0x59d45, 0x59d60, 0x5d7c3, 0x5d7e0,
    0x5dcbd, 0x5f000, 0x5f43d, 0x60000, 0x62697, 0x626a0,
    0x64761, 0x1c0200, 0x1c03e1,
  };

  enum class _Gcb_property {
    _Gcb_Other = 0,
    _Gcb_Control = 1,
    _Gcb_LF = 2,
    _Gcb_CR = 3,
    _Gcb_Extend = 4,
    _Gcb_Prepend = 5,
    _Gcb_SpacingMark = 6,
    _Gcb_L = 7,
    _Gcb_V = 8,
    _Gcb_T = 9,
    _Gcb_ZWJ = 10,
    _Gcb_LV = 11,
    _Gcb_LVT = 12,
    _Gcb_Regional_Indicator = 13,
  };




  inline constexpr int __gcb_shift_bits = 0x4;
  inline constexpr uint32_t __gcb_edges[] = {
    0x1, 0xa2, 0xb1, 0xd3, 0xe1, 0x200,
    0x7f1, 0xa00, 0xad1, 0xae0, 0x3004, 0x3700,
    0x4834, 0x48a0, 0x5914, 0x5be0, 0x5bf4, 0x5c00,
    0x5c14, 0x5c30, 0x5c44, 0x5c60, 0x5c74, 0x5c80,
    0x6005, 0x6060, 0x6104, 0x61b0, 0x61c1, 0x61d0,
    0x64b4, 0x6600, 0x6704, 0x6710, 0x6d64, 0x6dd5,
    0x6de0, 0x6df4, 0x6e50, 0x6e74, 0x6e90, 0x6ea4,
    0x6ee0, 0x70f5, 0x7100, 0x7114, 0x7120, 0x7304,
    0x74b0, 0x7a64, 0x7b10, 0x7eb4, 0x7f40, 0x7fd4,
    0x7fe0, 0x8164, 0x81a0, 0x81b4, 0x8240, 0x8254,
    0x8280, 0x8294, 0x82e0, 0x8594, 0x85c0, 0x8905,
    0x8920, 0x8974, 0x8a00, 0x8ca4, 0x8e25, 0x8e34,
    0x9036, 0x9040, 0x93a4, 0x93b6, 0x93c4, 0x93d0,
    0x93e6, 0x9414, 0x9496, 0x94d4, 0x94e6, 0x9500,
    0x9514, 0x9580, 0x9624, 0x9640, 0x9814, 0x9826,
    0x9840, 0x9bc4, 0x9bd0, 0x9be4, 0x9bf6, 0x9c14,
    0x9c50, 0x9c76, 0x9c90, 0x9cb6, 0x9cd4, 0x9ce0,
    0x9d74, 0x9d80, 0x9e24, 0x9e40, 0x9fe4, 0x9ff0,
    0xa014, 0xa036, 0xa040, 0xa3c4, 0xa3d0, 0xa3e6,
    0xa414, 0xa430, 0xa474, 0xa490, 0xa4b4, 0xa4e0,
    0xa514, 0xa520, 0xa704, 0xa720, 0xa754, 0xa760,
    0xa814, 0xa836, 0xa840, 0xabc4, 0xabd0, 0xabe6,
    0xac14, 0xac60, 0xac74, 0xac96, 0xaca0, 0xacb6,
    0xacd4, 0xace0, 0xae24, 0xae40, 0xafa4, 0xb000,
    0xb014, 0xb026, 0xb040, 0xb3c4, 0xb3d0, 0xb3e4,
    0xb406, 0xb414, 0xb450, 0xb476, 0xb490, 0xb4b6,
    0xb4d4, 0xb4e0, 0xb554, 0xb580, 0xb624, 0xb640,
    0xb824, 0xb830, 0xbbe4, 0xbbf6, 0xbc04, 0xbc16,
    0xbc30, 0xbc66, 0xbc90, 0xbca6, 0xbcd4, 0xbce0,
    0xbd74, 0xbd80, 0xc004, 0xc016, 0xc044, 0xc050,
    0xc3c4, 0xc3d0, 0xc3e4, 0xc416, 0xc450, 0xc464,
    0xc490, 0xc4a4, 0xc4e0, 0xc554, 0xc570, 0xc624,
    0xc640, 0xc814, 0xc826, 0xc840, 0xcbc4, 0xcbd0,
    0xcbe6, 0xcbf4, 0xcc16, 0xcc24, 0xcc36, 0xcc50,
    0xcc64, 0xcc90, 0xcca4, 0xcce0, 0xcd54, 0xcd70,
    0xce24, 0xce40, 0xcf36, 0xcf40, 0xd004, 0xd026,
    0xd040, 0xd3b4, 0xd3d0, 0xd3e4, 0xd3f6, 0xd414,
    0xd450, 0xd466, 0xd490, 0xd4a6, 0xd4d4, 0xd4e5,
    0xd4f0, 0xd574, 0xd580, 0xd624, 0xd640, 0xd814,
    0xd826, 0xd840, 0xdca4, 0xdcb0, 0xdcf4, 0xdd06,
    0xdd24, 0xdd50, 0xdd64, 0xdd70, 0xdd86, 0xddf4,
    0xde00, 0xdf26, 0xdf40, 0xe314, 0xe320, 0xe336,
    0xe344, 0xe3b0, 0xe474, 0xe4f0, 0xeb14, 0xeb20,
    0xeb36, 0xeb44, 0xebd0, 0xec84, 0xecf0, 0xf184,
    0xf1a0, 0xf354, 0xf360, 0xf374, 0xf380, 0xf394,
    0xf3a0, 0xf3e6, 0xf400, 0xf714, 0xf7f6, 0xf804,
    0xf850, 0xf864, 0xf880, 0xf8d4, 0xf980, 0xf994,
    0xfbd0, 0xfc64, 0xfc70, 0x102d4, 0x10316, 0x10324,
    0x10380, 0x10394, 0x103b6, 0x103d4, 0x103f0, 0x10566,
    0x10584, 0x105a0, 0x105e4, 0x10610, 0x10714, 0x10750,
    0x10824, 0x10830, 0x10846, 0x10854, 0x10870, 0x108d4,
    0x108e0, 0x109d4, 0x109e0, 0x11007, 0x11608, 0x11a89,
    0x12000, 0x135d4, 0x13600, 0x17124, 0x17160, 0x17324,
    0x17350, 0x17524, 0x17540, 0x17724, 0x17740, 0x17b44,
    0x17b66, 0x17b74, 0x17be6, 0x17c64, 0x17c76, 0x17c94,
    0x17d40, 0x17dd4, 0x17de0, 0x180b4, 0x180e1, 0x180f4,
    0x18100, 0x18854, 0x18870, 0x18a94, 0x18aa0, 0x19204,
    0x19236, 0x19274, 0x19296, 0x192c0, 0x19306, 0x19324,
    0x19336, 0x19394, 0x193c0, 0x1a174, 0x1a196, 0x1a1b4,
    0x1a1c0, 0x1a556, 0x1a564, 0x1a576, 0x1a584, 0x1a5f0,
    0x1a604, 0x1a610, 0x1a624, 0x1a630, 0x1a654, 0x1a6d6,
    0x1a734, 0x1a7d0, 0x1a7f4, 0x1a800, 0x1ab04, 0x1acf0,
    0x1b004, 0x1b046, 0x1b050, 0x1b344, 0x1b3e6, 0x1b424,
    0x1b450, 0x1b6b4, 0x1b740, 0x1b804, 0x1b826, 0x1b830,
    0x1ba16, 0x1ba24, 0x1ba66, 0x1ba84, 0x1bae0, 0x1be64,
    0x1be76, 0x1be84, 0x1bea6, 0x1bed4, 0x1bee6, 0x1bef4,
    0x1bf40, 0x1c246, 0x1c2c4, 0x1c346, 0x1c364, 0x1c380,
    0x1cd04, 0x1cd30, 0x1cd44, 0x1ce16, 0x1ce24, 0x1ce90,
    0x1ced4, 0x1cee0, 0x1cf44, 0x1cf50, 0x1cf76, 0x1cf84,
    0x1cfa0, 0x1dc04, 0x1e000, 0x200b1, 0x200c4, 0x200da,
    0x200e1, 0x20100, 0x20281, 0x202f0, 0x20601, 0x20700,
    0x20d04, 0x20f10, 0x2cef4, 0x2cf20, 0x2d7f4, 0x2d800,
    0x2de04, 0x2e000, 0x302a4, 0x30300, 0x30994, 0x309b0,
    0xa66f4, 0xa6730, 0xa6744, 0xa67e0, 0xa69e4, 0xa6a00,
    0xa6f04, 0xa6f20, 0xa8024, 0xa8030, 0xa8064, 0xa8070,
    0xa80b4, 0xa80c0, 0xa8236, 0xa8254, 0xa8276, 0xa8280,
    0xa82c4, 0xa82d0, 0xa8806, 0xa8820, 0xa8b46, 0xa8c44,
    0xa8c60, 0xa8e04, 0xa8f20, 0xa8ff4, 0xa9000, 0xa9264,
    0xa92e0, 0xa9474, 0xa9526, 0xa9534, 0xa9540, 0xa9607,
    0xa97d0, 0xa9804, 0xa9836, 0xa9840, 0xa9b34, 0xa9b46,
    0xa9b64, 0xa9ba6, 0xa9bc4, 0xa9be6, 0xa9c04, 0xa9c10,
    0xa9e54, 0xa9e60, 0xaa294, 0xaa2f6, 0xaa314, 0xaa336,
    0xaa354, 0xaa370, 0xaa434, 0xaa440, 0xaa4c4, 0xaa4d6,
    0xaa4e0, 0xaa7c4, 0xaa7d0, 0xaab04, 0xaab10, 0xaab24,
    0xaab50, 0xaab74, 0xaab90, 0xaabe4, 0xaac00, 0xaac14,
    0xaac20, 0xaaeb6, 0xaaec4, 0xaaee6, 0xaaf00, 0xaaf56,
    0xaaf64, 0xaaf70, 0xabe36, 0xabe54, 0xabe66, 0xabe84,
    0xabe96, 0xabeb0, 0xabec6, 0xabed4, 0xabee0, 0xac00b,
    0xac01c, 0xac1cb, 0xac1dc, 0xac38b, 0xac39c, 0xac54b,
    0xac55c, 0xac70b, 0xac71c, 0xac8cb, 0xac8dc, 0xaca8b,
    0xaca9c, 0xacc4b, 0xacc5c, 0xace0b, 0xace1c, 0xacfcb,
    0xacfdc, 0xad18b, 0xad19c, 0xad34b, 0xad35c, 0xad50b,
    0xad51c, 0xad6cb, 0xad6dc, 0xad88b, 0xad89c, 0xada4b,
    0xada5c, 0xadc0b, 0xadc1c, 0xaddcb, 0xadddc, 0xadf8b,
    0xadf9c, 0xae14b, 0xae15c, 0xae30b, 0xae31c, 0xae4cb,
    0xae4dc, 0xae68b, 0xae69c, 0xae84b, 0xae85c, 0xaea0b,
    0xaea1c, 0xaebcb, 0xaebdc, 0xaed8b, 0xaed9c, 0xaef4b,
    0xaef5c, 0xaf10b, 0xaf11c, 0xaf2cb, 0xaf2dc, 0xaf48b,
    0xaf49c, 0xaf64b, 0xaf65c, 0xaf80b, 0xaf81c, 0xaf9cb,
    0xaf9dc, 0xafb8b, 0xafb9c, 0xafd4b, 0xafd5c, 0xaff0b,
    0xaff1c, 0xb00cb, 0xb00dc, 0xb028b, 0xb029c, 0xb044b,
    0xb045c, 0xb060b, 0xb061c, 0xb07cb, 0xb07dc, 0xb098b,
    0xb099c, 0xb0b4b, 0xb0b5c, 0xb0d0b, 0xb0d1c, 0xb0ecb,
    0xb0edc, 0xb108b, 0xb109c, 0xb124b, 0xb125c, 0xb140b,
    0xb141c, 0xb15cb, 0xb15dc, 0xb178b, 0xb179c, 0xb194b,
    0xb195c, 0xb1b0b, 0xb1b1c, 0xb1ccb, 0xb1cdc, 0xb1e8b,
    0xb1e9c, 0xb204b, 0xb205c, 0xb220b, 0xb221c, 0xb23cb,
    0xb23dc, 0xb258b, 0xb259c, 0xb274b, 0xb275c, 0xb290b,
    0xb291c, 0xb2acb, 0xb2adc, 0xb2c8b, 0xb2c9c, 0xb2e4b,
    0xb2e5c, 0xb300b, 0xb301c, 0xb31cb, 0xb31dc, 0xb338b,
    0xb339c, 0xb354b, 0xb355c, 0xb370b, 0xb371c, 0xb38cb,
    0xb38dc, 0xb3a8b, 0xb3a9c, 0xb3c4b, 0xb3c5c, 0xb3e0b,
    0xb3e1c, 0xb3fcb, 0xb3fdc, 0xb418b, 0xb419c, 0xb434b,
    0xb435c, 0xb450b, 0xb451c, 0xb46cb, 0xb46dc, 0xb488b,
    0xb489c, 0xb4a4b, 0xb4a5c, 0xb4c0b, 0xb4c1c, 0xb4dcb,
    0xb4ddc, 0xb4f8b, 0xb4f9c, 0xb514b, 0xb515c, 0xb530b,
    0xb531c, 0xb54cb, 0xb54dc, 0xb568b, 0xb569c, 0xb584b,
    0xb585c, 0xb5a0b, 0xb5a1c, 0xb5bcb, 0xb5bdc, 0xb5d8b,
    0xb5d9c, 0xb5f4b, 0xb5f5c, 0xb610b, 0xb611c, 0xb62cb,
    0xb62dc, 0xb648b, 0xb649c, 0xb664b, 0xb665c, 0xb680b,
    0xb681c, 0xb69cb, 0xb69dc, 0xb6b8b, 0xb6b9c, 0xb6d4b,
    0xb6d5c, 0xb6f0b, 0xb6f1c, 0xb70cb, 0xb70dc, 0xb728b,
    0xb729c, 0xb744b, 0xb745c, 0xb760b, 0xb761c, 0xb77cb,
    0xb77dc, 0xb798b, 0xb799c, 0xb7b4b, 0xb7b5c, 0xb7d0b,
    0xb7d1c, 0xb7ecb, 0xb7edc, 0xb808b, 0xb809c, 0xb824b,
    0xb825c, 0xb840b, 0xb841c, 0xb85cb, 0xb85dc, 0xb878b,
    0xb879c, 0xb894b, 0xb895c, 0xb8b0b, 0xb8b1c, 0xb8ccb,
    0xb8cdc, 0xb8e8b, 0xb8e9c, 0xb904b, 0xb905c, 0xb920b,
    0xb921c, 0xb93cb, 0xb93dc, 0xb958b, 0xb959c, 0xb974b,
    0xb975c, 0xb990b, 0xb991c, 0xb9acb, 0xb9adc, 0xb9c8b,
    0xb9c9c, 0xb9e4b, 0xb9e5c, 0xba00b, 0xba01c, 0xba1cb,
    0xba1dc, 0xba38b, 0xba39c, 0xba54b, 0xba55c, 0xba70b,
    0xba71c, 0xba8cb, 0xba8dc, 0xbaa8b, 0xbaa9c, 0xbac4b,
    0xbac5c, 0xbae0b, 0xbae1c, 0xbafcb, 0xbafdc, 0xbb18b,
    0xbb19c, 0xbb34b, 0xbb35c, 0xbb50b, 0xbb51c, 0xbb6cb,
    0xbb6dc, 0xbb88b, 0xbb89c, 0xbba4b, 0xbba5c, 0xbbc0b,
    0xbbc1c, 0xbbdcb, 0xbbddc, 0xbbf8b, 0xbbf9c, 0xbc14b,
    0xbc15c, 0xbc30b, 0xbc31c, 0xbc4cb, 0xbc4dc, 0xbc68b,
    0xbc69c, 0xbc84b, 0xbc85c, 0xbca0b, 0xbca1c, 0xbcbcb,
    0xbcbdc, 0xbcd8b, 0xbcd9c, 0xbcf4b, 0xbcf5c, 0xbd10b,
    0xbd11c, 0xbd2cb, 0xbd2dc, 0xbd48b, 0xbd49c, 0xbd64b,
    0xbd65c, 0xbd80b, 0xbd81c, 0xbd9cb, 0xbd9dc, 0xbdb8b,
    0xbdb9c, 0xbdd4b, 0xbdd5c, 0xbdf0b, 0xbdf1c, 0xbe0cb,
    0xbe0dc, 0xbe28b, 0xbe29c, 0xbe44b, 0xbe45c, 0xbe60b,
    0xbe61c, 0xbe7cb, 0xbe7dc, 0xbe98b, 0xbe99c, 0xbeb4b,
    0xbeb5c, 0xbed0b, 0xbed1c, 0xbeecb, 0xbeedc, 0xbf08b,
    0xbf09c, 0xbf24b, 0xbf25c, 0xbf40b, 0xbf41c, 0xbf5cb,
    0xbf5dc, 0xbf78b, 0xbf79c, 0xbf94b, 0xbf95c, 0xbfb0b,
    0xbfb1c, 0xbfccb, 0xbfcdc, 0xbfe8b, 0xbfe9c, 0xc004b,
    0xc005c, 0xc020b, 0xc021c, 0xc03cb, 0xc03dc, 0xc058b,
    0xc059c, 0xc074b, 0xc075c, 0xc090b, 0xc091c, 0xc0acb,
    0xc0adc, 0xc0c8b, 0xc0c9c, 0xc0e4b, 0xc0e5c, 0xc100b,
    0xc101c, 0xc11cb, 0xc11dc, 0xc138b, 0xc139c, 0xc154b,
    0xc155c, 0xc170b, 0xc171c, 0xc18cb, 0xc18dc, 0xc1a8b,
    0xc1a9c, 0xc1c4b, 0xc1c5c, 0xc1e0b, 0xc1e1c, 0xc1fcb,
    0xc1fdc, 0xc218b, 0xc219c, 0xc234b, 0xc235c, 0xc250b,
    0xc251c, 0xc26cb, 0xc26dc, 0xc288b, 0xc289c, 0xc2a4b,
    0xc2a5c, 0xc2c0b, 0xc2c1c, 0xc2dcb, 0xc2ddc, 0xc2f8b,
    0xc2f9c, 0xc314b, 0xc315c, 0xc330b, 0xc331c, 0xc34cb,
    0xc34dc, 0xc368b, 0xc369c, 0xc384b, 0xc385c, 0xc3a0b,
    0xc3a1c, 0xc3bcb, 0xc3bdc, 0xc3d8b, 0xc3d9c, 0xc3f4b,
    0xc3f5c, 0xc410b, 0xc411c, 0xc42cb, 0xc42dc, 0xc448b,
    0xc449c, 0xc464b, 0xc465c, 0xc480b, 0xc481c, 0xc49cb,
    0xc49dc, 0xc4b8b, 0xc4b9c, 0xc4d4b, 0xc4d5c, 0xc4f0b,
    0xc4f1c, 0xc50cb, 0xc50dc, 0xc528b, 0xc529c, 0xc544b,
    0xc545c, 0xc560b, 0xc561c, 0xc57cb, 0xc57dc, 0xc598b,
    0xc599c, 0xc5b4b, 0xc5b5c, 0xc5d0b, 0xc5d1c, 0xc5ecb,
    0xc5edc, 0xc608b, 0xc609c, 0xc624b, 0xc625c, 0xc640b,
    0xc641c, 0xc65cb, 0xc65dc, 0xc678b, 0xc679c, 0xc694b,
    0xc695c, 0xc6b0b, 0xc6b1c, 0xc6ccb, 0xc6cdc, 0xc6e8b,
    0xc6e9c, 0xc704b, 0xc705c, 0xc720b, 0xc721c, 0xc73cb,
    0xc73dc, 0xc758b, 0xc759c, 0xc774b, 0xc775c, 0xc790b,
    0xc791c, 0xc7acb, 0xc7adc, 0xc7c8b, 0xc7c9c, 0xc7e4b,
    0xc7e5c, 0xc800b, 0xc801c, 0xc81cb, 0xc81dc, 0xc838b,
    0xc839c, 0xc854b, 0xc855c, 0xc870b, 0xc871c, 0xc88cb,
    0xc88dc, 0xc8a8b, 0xc8a9c, 0xc8c4b, 0xc8c5c, 0xc8e0b,
    0xc8e1c, 0xc8fcb, 0xc8fdc, 0xc918b, 0xc919c, 0xc934b,
    0xc935c, 0xc950b, 0xc951c, 0xc96cb, 0xc96dc, 0xc988b,
    0xc989c, 0xc9a4b, 0xc9a5c, 0xc9c0b, 0xc9c1c, 0xc9dcb,
    0xc9ddc, 0xc9f8b, 0xc9f9c, 0xca14b, 0xca15c, 0xca30b,
    0xca31c, 0xca4cb, 0xca4dc, 0xca68b, 0xca69c, 0xca84b,
    0xca85c, 0xcaa0b, 0xcaa1c, 0xcabcb, 0xcabdc, 0xcad8b,
    0xcad9c, 0xcaf4b, 0xcaf5c, 0xcb10b, 0xcb11c, 0xcb2cb,
    0xcb2dc, 0xcb48b, 0xcb49c, 0xcb64b, 0xcb65c, 0xcb80b,
    0xcb81c, 0xcb9cb, 0xcb9dc, 0xcbb8b, 0xcbb9c, 0xcbd4b,
    0xcbd5c, 0xcbf0b, 0xcbf1c, 0xcc0cb, 0xcc0dc, 0xcc28b,
    0xcc29c, 0xcc44b, 0xcc45c, 0xcc60b, 0xcc61c, 0xcc7cb,
    0xcc7dc, 0xcc98b, 0xcc99c, 0xccb4b, 0xccb5c, 0xccd0b,
    0xccd1c, 0xccecb, 0xccedc, 0xcd08b, 0xcd09c, 0xcd24b,
    0xcd25c, 0xcd40b, 0xcd41c, 0xcd5cb, 0xcd5dc, 0xcd78b,
    0xcd79c, 0xcd94b, 0xcd95c, 0xcdb0b, 0xcdb1c, 0xcdccb,
    0xcdcdc, 0xcde8b, 0xcde9c, 0xce04b, 0xce05c, 0xce20b,
    0xce21c, 0xce3cb, 0xce3dc, 0xce58b, 0xce59c, 0xce74b,
    0xce75c, 0xce90b, 0xce91c, 0xceacb, 0xceadc, 0xcec8b,
    0xcec9c, 0xcee4b, 0xcee5c, 0xcf00b, 0xcf01c, 0xcf1cb,
    0xcf1dc, 0xcf38b, 0xcf39c, 0xcf54b, 0xcf55c, 0xcf70b,
    0xcf71c, 0xcf8cb, 0xcf8dc, 0xcfa8b, 0xcfa9c, 0xcfc4b,
    0xcfc5c, 0xcfe0b, 0xcfe1c, 0xcffcb, 0xcffdc, 0xd018b,
    0xd019c, 0xd034b, 0xd035c, 0xd050b, 0xd051c, 0xd06cb,
    0xd06dc, 0xd088b, 0xd089c, 0xd0a4b, 0xd0a5c, 0xd0c0b,
    0xd0c1c, 0xd0dcb, 0xd0ddc, 0xd0f8b, 0xd0f9c, 0xd114b,
    0xd115c, 0xd130b, 0xd131c, 0xd14cb, 0xd14dc, 0xd168b,
    0xd169c, 0xd184b, 0xd185c, 0xd1a0b, 0xd1a1c, 0xd1bcb,
    0xd1bdc, 0xd1d8b, 0xd1d9c, 0xd1f4b, 0xd1f5c, 0xd210b,
    0xd211c, 0xd22cb, 0xd22dc, 0xd248b, 0xd249c, 0xd264b,
    0xd265c, 0xd280b, 0xd281c, 0xd29cb, 0xd29dc, 0xd2b8b,
    0xd2b9c, 0xd2d4b, 0xd2d5c, 0xd2f0b, 0xd2f1c, 0xd30cb,
    0xd30dc, 0xd328b, 0xd329c, 0xd344b, 0xd345c, 0xd360b,
    0xd361c, 0xd37cb, 0xd37dc, 0xd398b, 0xd399c, 0xd3b4b,
    0xd3b5c, 0xd3d0b, 0xd3d1c, 0xd3ecb, 0xd3edc, 0xd408b,
    0xd409c, 0xd424b, 0xd425c, 0xd440b, 0xd441c, 0xd45cb,
    0xd45dc, 0xd478b, 0xd479c, 0xd494b, 0xd495c, 0xd4b0b,
    0xd4b1c, 0xd4ccb, 0xd4cdc, 0xd4e8b, 0xd4e9c, 0xd504b,
    0xd505c, 0xd520b, 0xd521c, 0xd53cb, 0xd53dc, 0xd558b,
    0xd559c, 0xd574b, 0xd575c, 0xd590b, 0xd591c, 0xd5acb,
    0xd5adc, 0xd5c8b, 0xd5c9c, 0xd5e4b, 0xd5e5c, 0xd600b,
    0xd601c, 0xd61cb, 0xd61dc, 0xd638b, 0xd639c, 0xd654b,
    0xd655c, 0xd670b, 0xd671c, 0xd68cb, 0xd68dc, 0xd6a8b,
    0xd6a9c, 0xd6c4b, 0xd6c5c, 0xd6e0b, 0xd6e1c, 0xd6fcb,
    0xd6fdc, 0xd718b, 0xd719c, 0xd734b, 0xd735c, 0xd750b,
    0xd751c, 0xd76cb, 0xd76dc, 0xd788b, 0xd789c, 0xd7a40,
    0xd7b08, 0xd7c70, 0xd7cb9, 0xd7fc0, 0xfb1e4, 0xfb1f0,
    0xfe004, 0xfe100, 0xfe204, 0xfe300, 0xfeff1, 0xff000,
    0xff9e4, 0xffa00, 0xfff01, 0xfffc0, 0x101fd4, 0x101fe0,
    0x102e04, 0x102e10, 0x103764, 0x1037b0, 0x10a014, 0x10a040,
    0x10a054, 0x10a070, 0x10a0c4, 0x10a100, 0x10a384, 0x10a3b0,
    0x10a3f4, 0x10a400, 0x10ae54, 0x10ae70, 0x10d244, 0x10d280,
    0x10d694, 0x10d6e0, 0x10eab4, 0x10ead0, 0x10efc4, 0x10f000,
    0x10f464, 0x10f510, 0x10f824, 0x10f860, 0x110006, 0x110014,
    0x110026, 0x110030, 0x110384, 0x110470, 0x110704, 0x110710,
    0x110734, 0x110750, 0x1107f4, 0x110826, 0x110830, 0x110b06,
    0x110b34, 0x110b76, 0x110b94, 0x110bb0, 0x110bd5, 0x110be0,
    0x110c24, 0x110c30, 0x110cd5, 0x110ce0, 0x111004, 0x111030,
    0x111274, 0x1112c6, 0x1112d4, 0x111350, 0x111456, 0x111470,
    0x111734, 0x111740, 0x111804, 0x111826, 0x111830, 0x111b36,
    0x111b64, 0x111bf6, 0x111c04, 0x111c10, 0x111c25, 0x111c40,
    0x111c94, 0x111cd0, 0x111ce6, 0x111cf4, 0x111d00, 0x1122c6,
    0x1122f4, 0x112326, 0x112344, 0x112380, 0x1123e4, 0x1123f0,
    0x112414, 0x112420, 0x112df4, 0x112e06, 0x112e34, 0x112eb0,
    0x113004, 0x113026, 0x113040, 0x1133b4, 0x1133d0, 0x1133e4,
    0x1133f6, 0x113404, 0x113416, 0x113450, 0x113476, 0x113490,
    0x1134b6, 0x1134d4, 0x1134e0, 0x113574, 0x113580, 0x113626,
    0x113640, 0x113664, 0x1136d0, 0x113704, 0x113750, 0x113b84,
    0x113b96, 0x113bb4, 0x113c10, 0x113c24, 0x113c30, 0x113c54,
    0x113c60, 0x113c74, 0x113ca6, 0x113cb0, 0x113cc6, 0x113ce4,
    0x113d15, 0x113d24, 0x113d30, 0x113e14, 0x113e30, 0x114356,
    0x114384, 0x114406, 0x114424, 0x114456, 0x114464, 0x114470,
    0x1145e4, 0x1145f0, 0x114b04, 0x114b16, 0x114b34, 0x114b96,
    0x114ba4, 0x114bb6, 0x114bd4, 0x114be6, 0x114bf4, 0x114c16,
    0x114c24, 0x114c40, 0x115af4, 0x115b06, 0x115b24, 0x115b60,
    0x115b86, 0x115bc4, 0x115be6, 0x115bf4, 0x115c10, 0x115dc4,
    0x115de0, 0x116306, 0x116334, 0x1163b6, 0x1163d4, 0x1163e6,
    0x1163f4, 0x116410, 0x116ab4, 0x116ac6, 0x116ad4, 0x116ae6,
    0x116b04, 0x116b80, 0x1171d4, 0x1171e6, 0x1171f4, 0x117200,
    0x117224, 0x117266, 0x117274, 0x1172c0, 0x1182c6, 0x1182f4,
    0x118386, 0x118394, 0x1183b0, 0x119304, 0x119316, 0x119360,
    0x119376, 0x119390, 0x1193b4, 0x1193f5, 0x119406, 0x119415,
    0x119426, 0x119434, 0x119440, 0x119d16, 0x119d44, 0x119d80,
    0x119da4, 0x119dc6, 0x119e04, 0x119e10, 0x119e46, 0x119e50,
    0x11a014, 0x11a0b0, 0x11a334, 0x11a396, 0x11a3a5, 0x11a3b4,
    0x11a3f0, 0x11a474, 0x11a480, 0x11a514, 0x11a576, 0x11a594,
    0x11a5c0, 0x11a845, 0x11a8a4, 0x11a976, 0x11a984, 0x11a9a0,
    0x11c2f6, 0x11c304, 0x11c370, 0x11c384, 0x11c3e6, 0x11c3f4,
    0x11c400, 0x11c924, 0x11ca80, 0x11ca96, 0x11caa4, 0x11cb16,
    0x11cb24, 0x11cb46, 0x11cb54, 0x11cb70, 0x11d314, 0x11d370,
    0x11d3a4, 0x11d3b0, 0x11d3c4, 0x11d3e0, 0x11d3f4, 0x11d465,
    0x11d474, 0x11d480, 0x11d8a6, 0x11d8f0, 0x11d904, 0x11d920,
    0x11d936, 0x11d954, 0x11d966, 0x11d974, 0x11d980, 0x11ef34,
    0x11ef56, 0x11ef70, 0x11f004, 0x11f025, 0x11f036, 0x11f040,
    0x11f346, 0x11f364, 0x11f3b0, 0x11f3e6, 0x11f404, 0x11f430,
    0x11f5a4, 0x11f5b0, 0x134301, 0x134404, 0x134410, 0x134474,
    0x134560, 0x1611e4, 0x1612a6, 0x1612d4, 0x161300, 0x16af04,
    0x16af50, 0x16b304, 0x16b370, 0x16d638, 0x16d640, 0x16d678,
    0x16d6b0, 0x16f4f4, 0x16f500, 0x16f516, 0x16f880, 0x16f8f4,
    0x16f930, 0x16fe44, 0x16fe50, 0x16ff04, 0x16ff20, 0x1bc9d4,
    0x1bc9f0, 0x1bca01, 0x1bca40, 0x1cf004, 0x1cf2e0, 0x1cf304,
    0x1cf470, 0x1d1654, 0x1d16a0, 0x1d16d4, 0x1d1731, 0x1d17b4,
    0x1d1830, 0x1d1854, 0x1d18c0, 0x1d1aa4, 0x1d1ae0, 0x1d2424,
    0x1d2450, 0x1da004, 0x1da370, 0x1da3b4, 0x1da6d0, 0x1da754,
    0x1da760, 0x1da844, 0x1da850, 0x1da9b4, 0x1daa00, 0x1daa14,
    0x1dab00, 0x1e0004, 0x1e0070, 0x1e0084, 0x1e0190, 0x1e01b4,
    0x1e0220, 0x1e0234, 0x1e0250, 0x1e0264, 0x1e02b0, 0x1e08f4,
    0x1e0900, 0x1e1304, 0x1e1370, 0x1e2ae4, 0x1e2af0, 0x1e2ec4,
    0x1e2f00, 0x1e4ec4, 0x1e4f00, 0x1e5ee4, 0x1e5f00, 0x1e8d04,
    0x1e8d70, 0x1e9444, 0x1e94b0, 0x1f1e6d, 0x1f2000, 0x1f3fb4,
    0x1f4000, 0xe00001, 0xe00204, 0xe00801, 0xe01004, 0xe01f01,
    0xe10000,
  };

  inline constexpr char32_t __incb_linkers[] = {
    0x094d, 0x09cd, 0x0acd, 0x0b4d, 0x0c4d, 0x0d4d,
  };

  enum class _InCB { _Consonant = 1, _Extend = 2 };




  inline constexpr uint32_t __incb_edges[] = {
    0xc02, 0xdc0, 0x120e, 0x1228, 0x1646, 0x16f8,
    0x16fe, 0x1700, 0x1706, 0x170c, 0x1712, 0x1718,
    0x171e, 0x1720, 0x1842, 0x186c, 0x192e, 0x1980,
    0x19c2, 0x19c4, 0x1b5a, 0x1b74, 0x1b7e, 0x1b94,
    0x1b9e, 0x1ba4, 0x1baa, 0x1bb8, 0x1c46, 0x1c48,
    0x1cc2, 0x1d2c, 0x1e9a, 0x1ec4, 0x1fae, 0x1fd0,
    0x1ff6, 0x1ff8, 0x205a, 0x2068, 0x206e, 0x2090,
    0x2096, 0x20a0, 0x20a6, 0x20b8, 0x2166, 0x2170,
    0x225e, 0x2280, 0x232a, 0x2388, 0x238e, 0x240c,
    0x2455, 0x24ea, 0x24ec, 0x24f2, 0x24f4, 0x2506,
    0x2524, 0x2546, 0x2561, 0x2580, 0x258a, 0x2590,
    0x25e1, 0x2600, 0x2606, 0x2608, 0x2655, 0x26a4,
    0x26a9, 0x26c4, 0x26c9, 0x26cc, 0x26d9, 0x26e8,
    0x26f2, 0x26f4, 0x26fa, 0x26fc, 0x2706, 0x2714,
    0x275e, 0x2760, 0x2771, 0x2778, 0x277d, 0x2780,
    0x278a, 0x2790, 0x27c1, 0x27c8, 0x27fa, 0x27fc,
    0x2806, 0x280c, 0x28f2, 0x28f4, 0x2906, 0x290c,
    0x291e, 0x2924, 0x292e, 0x2938, 0x2946, 0x2948,
    0x29c2, 0x29c8, 0x29d6, 0x29d8, 0x2a06, 0x2a0c,
    0x2a55, 0x2aa4, 0x2aa9, 0x2ac4, 0x2ac9, 0x2ad0,
    0x2ad5, 0x2ae8, 0x2af2, 0x2af4, 0x2b06, 0x2b18,
    0x2b1e, 0x2b24, 0x2b8a, 0x2b90, 0x2be5, 0x2bea,
    0x2c00, 0x2c06, 0x2c08, 0x2c55, 0x2ca4, 0x2ca9,
    0x2cc4, 0x2cc9, 0x2cd0, 0x2cd5, 0x2ce8, 0x2cf2,
    0x2cf4, 0x2cfa, 0x2d00, 0x2d06, 0x2d14, 0x2d56,
    0x2d60, 0x2d71, 0x2d78, 0x2d7d, 0x2d80, 0x2d8a,
    0x2d90, 0x2dc5, 0x2dc8, 0x2e0a, 0x2e0c, 0x2efa,
    0x2efc, 0x2f02, 0x2f04, 0x2f36, 0x2f38, 0x2f5e,
    0x2f60, 0x3002, 0x3004, 0x3012, 0x3014, 0x3055,
    0x30a4, 0x30a9, 0x30e8, 0x30f2, 0x30f4, 0x30fa,
    0x3104, 0x311a, 0x3124, 0x312a, 0x3134, 0x3156,
    0x315c, 0x3161, 0x316c, 0x318a, 0x3190, 0x3206,
    0x3208, 0x32f2, 0x32f4, 0x32fe, 0x3304, 0x330a,
    0x330c, 0x331a, 0x3324, 0x332a, 0x3338, 0x3356,
    0x335c, 0x338a, 0x3390, 0x3402, 0x3408, 0x3455,
    0x34ee, 0x34f4, 0x34fa, 0x34fc, 0x3506, 0x3514,
    0x355e, 0x3560, 0x358a, 0x3590, 0x3606, 0x3608,
    0x372a, 0x372c, 0x373e, 0x3740, 0x374a, 0x3754,
    0x375a, 0x375c, 0x377e, 0x3780, 0x38c6, 0x38c8,
    0x38d2, 0x38ec, 0x391e, 0x393c, 0x3ac6, 0x3ac8,
    0x3ad2, 0x3af4, 0x3b22, 0x3b3c, 0x3c62, 0x3c68,
    0x3cd6, 0x3cd8, 0x3cde, 0x3ce0, 0x3ce6, 0x3ce8,
    0x3dc6, 0x3dfc, 0x3e02, 0x3e14, 0x3e1a, 0x3e20,
    0x3e36, 0x3e60, 0x3e66, 0x3ef4, 0x3f1a, 0x3f1c,
    0x40b6, 0x40c4, 0x40ca, 0x40e0, 0x40e6, 0x40ec,
    0x40f6, 0x40fc, 0x4162, 0x4168, 0x417a, 0x4184,
    0x41c6, 0x41d4, 0x420a, 0x420c, 0x4216, 0x421c,
    0x4236, 0x4238, 0x4276, 0x4278, 0x4d76, 0x4d80,
    0x5c4a, 0x5c58, 0x5cca, 0x5cd4, 0x5d4a, 0x5d50,
    0x5dca, 0x5dd0, 0x5ed2, 0x5ed8, 0x5ede, 0x5ef8,
    0x5f1a, 0x5f1c, 0x5f26, 0x5f50, 0x5f76, 0x5f78,
    0x602e, 0x6038, 0x603e, 0x6040, 0x6216, 0x621c,
    0x62a6, 0x62a8, 0x6482, 0x648c, 0x649e, 0x64a4,
    0x64ca, 0x64cc, 0x64e6, 0x64f0, 0x685e, 0x6864,
    0x686e, 0x6870, 0x695a, 0x695c, 0x6962, 0x697c,
    0x6982, 0x6984, 0x698a, 0x698c, 0x6996, 0x69b4,
    0x69ce, 0x69f4, 0x69fe, 0x6a00, 0x6ac2, 0x6b3c,
    0x6c02, 0x6c10, 0x6cd2, 0x6cf8, 0x6d0a, 0x6d14,
    0x6dae, 0x6dd0, 0x6e02, 0x6e08, 0x6e8a, 0x6e98,
    0x6ea2, 0x6eb8, 0x6f9a, 0x6f9c, 0x6fa2, 0x6fa8,
    0x6fb6, 0x6fb8, 0x6fbe, 0x6fd0, 0x70b2, 0x70d0,
    0x70da, 0x70e0, 0x7342, 0x734c, 0x7352, 0x7384,
    0x738a, 0x73a4, 0x73b6, 0x73b8, 0x73d2, 0x73d4,
    0x73e2, 0x73e8, 0x7702, 0x7800, 0x8036, 0x8038,
    0x8342, 0x83c4, 0xb3be, 0xb3c8, 0xb5fe, 0xb600,
    0xb782, 0xb800, 0xc0aa, 0xc0c0, 0xc266, 0xc26c,
    0x299be, 0x299cc, 0x299d2, 0x299f8, 0x29a7a, 0x29a80,
    0x29bc2, 0x29bc8, 0x2a00a, 0x2a00c, 0x2a01a, 0x2a01c,
    0x2a02e, 0x2a030, 0x2a096, 0x2a09c, 0x2a0b2, 0x2a0b4,
    0x2a312, 0x2a318, 0x2a382, 0x2a3c8, 0x2a3fe, 0x2a400,
    0x2a49a, 0x2a4b8, 0x2a51e, 0x2a548, 0x2a54e, 0x2a550,
    0x2a602, 0x2a60c, 0x2a6ce, 0x2a6d0, 0x2a6da, 0x2a6e8,
    0x2a6f2, 0x2a6f8, 0x2a702, 0x2a704, 0x2a796, 0x2a798,
    0x2a8a6, 0x2a8bc, 0x2a8c6, 0x2a8cc, 0x2a8d6, 0x2a8dc,
    0x2a90e, 0x2a910, 0x2a932, 0x2a934, 0x2a9f2, 0x2a9f4,
    0x2aac2, 0x2aac4, 0x2aaca, 0x2aad4, 0x2aade, 0x2aae4,
    0x2aafa, 0x2ab00, 0x2ab06, 0x2ab08, 0x2abb2, 0x2abb8,
    0x2abda, 0x2abdc, 0x2af96, 0x2af98, 0x2afa2, 0x2afa4,
    0x2afb6, 0x2afb8, 0x3ec7a, 0x3ec7c, 0x3f802, 0x3f840,
    0x3f882, 0x3f8c0, 0x3fe7a, 0x3fe80, 0x407f6, 0x407f8,
    0x40b82, 0x40b84, 0x40dda, 0x40dec, 0x42806, 0x42810,
    0x42816, 0x4281c, 0x42832, 0x42840, 0x428e2, 0x428ec,
    0x428fe, 0x42900, 0x42b96, 0x42b9c, 0x43492, 0x434a0,
    0x435a6, 0x435b8, 0x43aae, 0x43ab4, 0x43bf2, 0x43c00,
    0x43d1a, 0x43d44, 0x43e0a, 0x43e18, 0x44006, 0x44008,
    0x440e2, 0x4411c, 0x441c2, 0x441c4, 0x441ce, 0x441d4,
    0x441fe, 0x44208, 0x442ce, 0x442dc, 0x442e6, 0x442ec,
    0x4430a, 0x4430c, 0x44402, 0x4440c, 0x4449e, 0x444b0,
    0x444b6, 0x444d4, 0x445ce, 0x445d0, 0x44602, 0x44608,
    0x446da, 0x446fc, 0x44702, 0x44704, 0x44726, 0x44734,
    0x4473e, 0x44740, 0x448be, 0x448c8, 0x448d2, 0x448e0,
    0x448fa, 0x448fc, 0x44906, 0x44908, 0x44b7e, 0x44b80,
    0x44b8e, 0x44bac, 0x44c02, 0x44c08, 0x44cee, 0x44cf4,
    0x44cfa, 0x44cfc, 0x44d02, 0x44d04, 0x44d36, 0x44d38,
    0x44d5e, 0x44d60, 0x44d9a, 0x44db4, 0x44dc2, 0x44dd4,
    0x44ee2, 0x44ee4, 0x44eee, 0x44f04, 0x44f0a, 0x44f0c,
    0x44f16, 0x44f18, 0x44f1e, 0x44f28, 0x44f3a, 0x44f44,
    0x44f4a, 0x44f4c, 0x44f86, 0x44f8c, 0x450e2, 0x45100,
    0x4510a, 0x45114, 0x4511a, 0x4511c, 0x4517a, 0x4517c,
    0x452c2, 0x452c4, 0x452ce, 0x452e4, 0x452ea, 0x452ec,
    0x452f6, 0x452f8, 0x452fe, 0x45304, 0x4530a, 0x45310,
    0x456be, 0x456c0, 0x456ca, 0x456d8, 0x456f2, 0x456f8,
    0x456fe, 0x45704, 0x45772, 0x45778, 0x458ce, 0x458ec,
    0x458f6, 0x458f8, 0x458fe, 0x45904, 0x45aae, 0x45ab0,
    0x45ab6, 0x45ab8, 0x45ac2, 0x45ae0, 0x45c76, 0x45c78,
    0x45c7e, 0x45c80, 0x45c8a, 0x45c98, 0x45c9e, 0x45cb0,
    0x460be, 0x460e0, 0x460e6, 0x460ec, 0x464c2, 0x464c4,
    0x464ee, 0x464fc, 0x4650e, 0x46510, 0x46752, 0x46760,
    0x4676a, 0x46770, 0x46782, 0x46784, 0x46806, 0x4682c,
    0x468ce, 0x468e4, 0x468ee, 0x468fc, 0x4691e, 0x46920,
    0x46946, 0x4695c, 0x46966, 0x46970, 0x46a2a, 0x46a5c,
    0x46a62, 0x46a68, 0x470c2, 0x470dc, 0x470e2, 0x470f8,
    0x470fe, 0x47100, 0x4724a, 0x472a0, 0x472aa, 0x472c4,
    0x472ca, 0x472d0, 0x472d6, 0x472dc, 0x474c6, 0x474dc,
    0x474ea, 0x474ec, 0x474f2, 0x474f8, 0x474fe, 0x47518,
    0x4751e, 0x47520, 0x47642, 0x47648, 0x47656, 0x47658,
    0x4765e, 0x47660, 0x47bce, 0x47bd4, 0x47c02, 0x47c08,
    0x47cda, 0x47cec, 0x47d02, 0x47d0c, 0x47d6a, 0x47d6c,
    0x4d102, 0x4d104, 0x4d11e, 0x4d158, 0x5847a, 0x584a8,
    0x584b6, 0x584c0, 0x5abc2, 0x5abd4, 0x5acc2, 0x5acdc,
    0x5bd3e, 0x5bd40, 0x5be3e, 0x5be4c, 0x5bf92, 0x5bf94,
    0x5bfc2, 0x5bfc8, 0x6f276, 0x6f27c, 0x73c02, 0x73cb8,
    0x73cc2, 0x73d1c, 0x74596, 0x745a8, 0x745b6, 0x745cc,
    0x745ee, 0x7460c, 0x74616, 0x74630, 0x746aa, 0x746b8,
    0x7490a, 0x74914, 0x76802, 0x768dc, 0x768ee, 0x769b4,
    0x769d6, 0x769d8, 0x76a12, 0x76a14, 0x76a6e, 0x76a80,
    0x76a86, 0x76ac0, 0x78002, 0x7801c, 0x78022, 0x78064,
    0x7806e, 0x78088, 0x7808e, 0x78094, 0x7809a, 0x780ac,
    0x7823e, 0x78240, 0x784c2, 0x784dc, 0x78aba, 0x78abc,
    0x78bb2, 0x78bc0, 0x793b2, 0x793c0, 0x797ba, 0x797c0,
    0x7a342, 0x7a35c, 0x7a512, 0x7a52c, 0x7cfee, 0x7d000,
    0x380082, 0x380200, 0x380402, 0x3807c0,
  };



  inline constexpr char32_t __xpicto_edges[] = {
    0xa9, 0xaa, 0xae, 0xaf, 0x203c, 0x203d, 0x2049, 0x204a,
    0x2122, 0x2123, 0x2139, 0x213a, 0x2194, 0x219a, 0x21a9, 0x21ab,
    0x231a, 0x231c, 0x2328, 0x2329, 0x2388, 0x2389, 0x23cf, 0x23d0,
    0x23e9, 0x23f4, 0x23f8, 0x23fb, 0x24c2, 0x24c3, 0x25aa, 0x25ac,
    0x25b6, 0x25b7, 0x25c0, 0x25c1, 0x25fb, 0x25ff, 0x2600, 0x2606,
    0x2607, 0x2613, 0x2614, 0x2686, 0x2690, 0x2706, 0x2708, 0x2713,
    0x2714, 0x2715, 0x2716, 0x2717, 0x271d, 0x271e, 0x2721, 0x2722,
    0x2728, 0x2729, 0x2733, 0x2735, 0x2744, 0x2745, 0x2747, 0x2748,
    0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758,
    0x2763, 0x2768, 0x2795, 0x2798, 0x27a1, 0x27a2, 0x27b0, 0x27b1,
    0x27bf, 0x27c0, 0x2934, 0x2936, 0x2b05, 0x2b08, 0x2b1b, 0x2b1d,
    0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x3030, 0x3031, 0x303d, 0x303e,
    0x3297, 0x3298, 0x3299, 0x329a, 0x1f000, 0x1f100, 0x1f10d, 0x1f110,
    0x1f12f, 0x1f130, 0x1f16c, 0x1f172, 0x1f17e, 0x1f180, 0x1f18e, 0x1f18f,
    0x1f191, 0x1f19b, 0x1f1ad, 0x1f1e6, 0x1f201, 0x1f210, 0x1f21a, 0x1f21b,
    0x1f22f, 0x1f230, 0x1f232, 0x1f23b, 0x1f23c, 0x1f240, 0x1f249, 0x1f3fb,
    0x1f400, 0x1f53e, 0x1f546, 0x1f650, 0x1f680, 0x1f700, 0x1f774, 0x1f780,
    0x1f7d5, 0x1f800, 0x1f80c, 0x1f810, 0x1f848, 0x1f850, 0x1f85a, 0x1f860,
    0x1f888, 0x1f890, 0x1f8ae, 0x1f900, 0x1f90c, 0x1f93b, 0x1f93c, 0x1f946,
    0x1f947, 0x1fb00, 0x1fc00, 0x1fffe,
  };
# 602 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode.h" 2 3





  constexpr int
  __field_width(char32_t __c) noexcept
  {
    if (__c < __width_edges[0]) [[likely]]
      return 1;

    auto* __p = std::upper_bound(__width_edges, std::end(__width_edges), __c);
    return (__p - __width_edges) % 2 + 1;
  }


  constexpr bool
  __should_escape_category(char32_t __c) noexcept
  {
    constexpr uint32_t __mask = 0x01;
    auto* __end = std::end(__escape_edges);
    auto* __p = std::lower_bound(__escape_edges, __end,
     (__c << 1u) + 2);
    return __p[-1] & __mask;
  }



  constexpr _Gcb_property
  __grapheme_cluster_break_property(char32_t __c) noexcept
  {
    constexpr uint32_t __mask = (1 << __gcb_shift_bits) - 1;
    auto* __end = std::end(__gcb_edges);
    auto* __p = std::lower_bound(__gcb_edges, __end,
     (__c << __gcb_shift_bits) | __mask);
    return _Gcb_property(__p[-1] & __mask);
  }

  constexpr bool
  __is_incb_linker(char32_t __c) noexcept
  {
    const auto __end = std::end(__incb_linkers);

    return std::find(__incb_linkers, __end, __c) != __end;
  }


  constexpr _InCB
  __incb_property(char32_t __c) noexcept
  {
    if ((__c << 2) < __incb_edges[0]) [[likely]]
      return _InCB(0);

    constexpr uint32_t __mask = 0x3;
    auto* __end = std::end(__incb_edges);
    auto* __p = std::lower_bound(__incb_edges, __end, (__c << 2) | __mask);
    return _InCB(__p[-1] & __mask);
  }

  constexpr bool
  __is_extended_pictographic(char32_t __c)
  {
    if (__c < __xpicto_edges[0]) [[likely]]
      return 0;

    auto* __p = std::upper_bound(__xpicto_edges, std::end(__xpicto_edges), __c);
    return (__p - __xpicto_edges) % 2;
  }

  struct _Grapheme_cluster_iterator_base
  {
    char32_t _M_c;
    _Gcb_property _M_prop;
    enum class _XPicto : unsigned char { _Init, _Zwj, _Matched, _Failed };
    _XPicto _M_xpicto_seq_state = _XPicto::_Init;
    unsigned char _M_RI_count = 0;
    bool _M_incb_linker_seen = false;

    constexpr void
    _M_reset(char32_t __c, _Gcb_property __p)
    {
      _M_c = __c;
      _M_prop = __p;
      _M_xpicto_seq_state = _XPicto::_Init;
      _M_RI_count = 0;
      _M_incb_linker_seen = false;
    }

    constexpr void
    _M_update_xpicto_seq_state(char32_t __c, _Gcb_property __p)
    {
      if (_M_xpicto_seq_state == _XPicto::_Failed)
 return;

      auto __next_state = _XPicto::_Failed;
      if (_M_xpicto_seq_state != _XPicto::_Zwj)
 {
   if (__p == _Gcb_property::_Gcb_ZWJ)
     {
       if (_M_xpicto_seq_state == _XPicto::_Matched)
  __next_state = _XPicto::_Zwj;


       else if (__is_extended_pictographic(_M_c))
  __next_state = _XPicto::_Zwj;
     }
   else if (__p == _Gcb_property::_Gcb_Extend)
     __next_state = _M_xpicto_seq_state;
 }
      else
 {


   if (__p == _Gcb_property::_Gcb_Other
  && __is_extended_pictographic(__c))
     __next_state = _XPicto::_Matched;
 }
      _M_xpicto_seq_state = __next_state;
    }

    constexpr void
    _M_update_ri_count(_Gcb_property __p)
    {
      if (__p == _Gcb_property::_Gcb_Regional_Indicator)
 ++_M_RI_count;
      else
 _M_RI_count = 0;
    }

    constexpr void
    _M_update_incb_state(char32_t __c, _Gcb_property)
    {
      if (__is_incb_linker(__c))
 _M_incb_linker_seen = true;
    }
  };


  template<ranges::forward_range _View> requires ranges::view<_View>
    class _Grapheme_cluster_view
    : public ranges::view_interface<_Grapheme_cluster_view<_View>>
    {
    public:

      constexpr
      _Grapheme_cluster_view(_View __v)
      : _M_begin(_Utf32_view<_View>(std::move(__v)).begin())
      { }

      constexpr auto begin() const { return _M_begin; }
      constexpr auto end() const { return _M_begin.end(); }

    private:
      struct _Iterator : private _Grapheme_cluster_iterator_base
      {
      private:

 using _U32_iterator = ranges::iterator_t<_Utf32_view<_View>>;

      public:





 using value_type = char32_t;
 using iterator_concept = forward_iterator_tag;
 using difference_type = ptrdiff_t;

 constexpr
 _Iterator(_U32_iterator __i)
 : _M_base(__i)
 {
   if (__i != __i.end())
     {
       _M_c = *__i;
       _M_prop = __grapheme_cluster_break_property(_M_c);
     }
 }


 constexpr value_type
 operator*() const
 { return _M_c; }

 constexpr auto
 operator->() const
 { return &_M_c; }


 constexpr _Iterator&
 operator++()
 {
   const auto __end = _M_base.end();
   if (_M_base != __end)
     {
       auto __p_prev = _M_prop;
       auto __it = _M_base;
       while (++__it != __end)
  {
    char32_t __c = *__it;
    auto __p = __grapheme_cluster_break_property(*__it);
    _M_update_xpicto_seq_state(__c, __p);
    _M_update_ri_count(__p);
    _M_update_incb_state(__c, __p);
    if (_M_is_break(__p_prev, __p, __it))
      {

        _M_reset(__c, __p);
        break;
      }
    __p_prev = __p;
  }
       _M_base = __it;
     }
   return *this;
 }

 constexpr _Iterator
 operator++(int)
 {
   auto __tmp = *this;
   ++*this;
   return __tmp;
 }

 constexpr bool
 operator==(const _Iterator& __i) const
 { return _M_base == __i._M_base; }


 constexpr bool
 operator==(const ranges::sentinel_t<_View>& __i) const
 { return _M_base == __i; }


 constexpr auto base() const { return _M_base.base(); }


 constexpr auto end() const { return _M_base.end(); }


 constexpr int
 width() const noexcept
 { return __field_width(_M_c); }

      private:
 _U32_iterator _M_base;






 constexpr bool
 _M_is_break(_Gcb_property __p1, _Gcb_property __p2,
      _U32_iterator __curr) const
 {
   using enum _Gcb_property;

   if (__p1 == _Gcb_Control || __p1 == _Gcb_LF)
     return true;

   if (__p1 == _Gcb_CR)
     return __p2 != _Gcb_LF;


   if (__p2 == _Gcb_Control || __p2 == _Gcb_CR || __p2 == _Gcb_LF)
     return true;


   if (__p1 == _Gcb_L)
     switch (__p2)
     {
       case _Gcb_L:
       case _Gcb_V:
       case _Gcb_LV:
       case _Gcb_LVT:
  return false;
       default:
  return true;
       }


   if (__p1 == _Gcb_LV || __p1 == _Gcb_V)
     switch (__p2)
     {
       case _Gcb_V:
       case _Gcb_T:
  return false;
       default:
  return true;
       }


   if (__p1 == _Gcb_LVT || __p1 == _Gcb_T)
     return __p2 != _Gcb_T;


   if (__p2 == _Gcb_Extend || __p2 == _Gcb_ZWJ)
     return false;





   if (__p2 == _Gcb_SpacingMark)
     return false;

   if (__p1 == _Gcb_Prepend)
     return false;




   if (_M_incb_linker_seen
  && __incb_property(_M_c) == _InCB::_Consonant
  && __incb_property(*__curr) == _InCB::_Consonant)
     {


       bool __have_linker = false;
       auto __it = _M_base;
       while (++__it != __curr)
  {
    if (__is_incb_linker(*__it))
      __have_linker = true;
    else
      {
        auto __incb = __incb_property(*__it);
        if (__incb == _InCB::_Consonant)
   __have_linker = false;
        else if (__incb != _InCB::_Extend)
   break;
      }
  }
       if (__it == __curr && __have_linker)
  return false;
     }




   if (__p1 == _Gcb_ZWJ && _M_xpicto_seq_state == _XPicto::_Matched)
     return false;





   if (__p1 == _Gcb_property::_Gcb_Regional_Indicator && __p1 == __p2)
     return (_M_RI_count & 1) == 0;


   return true;
 }
      };

      _Iterator _M_begin;
    };

}


  template<typename _CharT>
    constexpr size_t
    __field_width(basic_string_view<_CharT> __s)
    {
      if (__s.empty()) [[unlikely]]
 return 0;
      _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
      auto __it = __gc.begin();
      const auto __end = __gc.end();
      size_t __n = __it.width();
      while (++__it != __end)
 __n += __it.width();
      return __n;
    }



  template<typename _CharT>
    constexpr size_t
    __truncate(basic_string_view<_CharT>& __s, size_t __max)
    {
      if (__s.empty()) [[unlikely]]
 return 0;

      _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
      auto __it = __gc.begin();
      const auto __end = __gc.end();
      size_t __n = __it.width();
      if (__n > __max)
 {
   __s = {};
   return 0;
 }
      while (++__it != __end)
 {
   size_t __n2 = __n + __it.width();
   if (__n2 > __max)
     {
       __s = basic_string_view<_CharT>(__s.begin(), __it.base());
       return __n;
     }
   __n = __n2;
 }
      return __n;
    }

  template<typename _CharT>
    consteval bool
    __literal_encoding_is_unicode()
    {
      if constexpr (is_same_v<_CharT, char16_t>)
 return true;
      else if constexpr (is_same_v<_CharT, char32_t>)
   return true;

      else if constexpr (is_same_v<_CharT, char8_t>)
 return true;


      const char* __enc = "";
# 1065 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/unicode.h" 3
      if constexpr (is_same_v<_CharT, char>)
 __enc = "UTF-8";

      else
 __enc = "UTF-32";


      string_view __s(__enc);
      if (__s == "UTF-8")
 return true;
      else if constexpr (!is_same_v<_CharT, char>)
 return __s == "UTF-16" || __s == "UTF-32";


      return false;
    }

  consteval bool
  __literal_encoding_is_utf8()
  { return __literal_encoding_is_unicode<char>(); }

  consteval bool
  __literal_encoding_is_extended_ascii()
  {
    return '0' == 0x30 && 'A' == 0x41 && 'Z' == 0x5a
      && 'a' == 0x61 && 'z' == 0x7a;
  }


  constexpr bool
  __charset_alias_match(string_view __a, string_view __b)
  {

    auto __map = [](char __c, bool& __num) -> unsigned char {
      if (__c == '0') [[unlikely]]
 return __num ? 0 : 127;
      const auto __v = __detail::__from_chars_alnum_to_val(__c);
      __num = __v < 10;
      return __v;
    };

    auto __ptr_a = __a.begin(), __end_a = __a.end();
    auto __ptr_b = __b.begin(), __end_b = __b.end();
    bool __num_a = false, __num_b = false;

    while (true)
      {

 unsigned char __val_a{}, __val_b{};
 while (__ptr_a != __end_a
   && (__val_a = __map(*__ptr_a, __num_a)) == 127)
   ++__ptr_a;
 while (__ptr_b != __end_b
   && (__val_b = __map(*__ptr_b, __num_b)) == 127)
   ++__ptr_b;

 if (__ptr_a == __end_a)
   return __ptr_b == __end_b;
 else if (__ptr_b == __end_b)
   return false;
 else if (__val_a != __val_b)
   return false;
 ++__ptr_a;
 ++__ptr_b;
      }
    return true;
  }

}

namespace ranges
{
  template<typename _To, typename _Range>
    inline constexpr bool
    enable_borrowed_range<std::__unicode::_Utf_view<_To, _Range>>
      = enable_borrowed_range<_Range>;

  template<typename _Range>
    inline constexpr bool
    enable_borrowed_range<std::__unicode::_Grapheme_cluster_view<_Range>>
      = enable_borrowed_range<_Range>;
}


}
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 2 3







#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wc++23-extensions"

namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _CharT, typename... _Args> struct basic_format_string;


namespace __format
{





  template<typename _CharT>
    consteval auto
    _Widen(const char* __narrow, const wchar_t* __wide)
    {
      if constexpr (is_same_v<_CharT, wchar_t>)
 return __wide;
      else
 return __narrow;
    }




  template<typename _CharT>
  constexpr size_t __stackbuf_size = 32 * sizeof(void*) / sizeof(_CharT);


  template<typename _CharT> class _Sink;
  template<typename _CharT> class _Fixedbuf_sink;
  template<typename _Seq> class _Seq_sink;

  template<typename _CharT, typename _Alloc = allocator<_CharT>>
    using _Str_sink
      = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;





  template<typename _CharT>
    class _Sink_iter;


  template<typename _CharT>
    struct _Iter_for
    { using type = back_insert_iterator<basic_string<_CharT>>; };

  template<typename _CharT>
    using __format_context = basic_format_context<_Sink_iter<_CharT>, _CharT>;

  template<typename _CharT>
    struct _Runtime_format_string
    {
      [[__gnu__::__always_inline__]]
      _Runtime_format_string(basic_string_view<_CharT> __s) noexcept
      : _M_str(__s) { }

      _Runtime_format_string(const _Runtime_format_string&) = delete;
      void operator=(const _Runtime_format_string&) = delete;

    private:
      basic_string_view<_CharT> _M_str;

      template<typename, typename...> friend struct std::basic_format_string;
    };

}


  using format_context = __format::__format_context<char>;

  using wformat_context = __format::__format_context<wchar_t>;



  template<typename _Context> class basic_format_args;
  using format_args = basic_format_args<format_context>;

  using wformat_args = basic_format_args<wformat_context>;




  template<typename _Context>
    class basic_format_arg;





  template<typename _CharT, typename... _Args>
    struct basic_format_string
    {
      template<typename _Tp>
 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
 consteval
 basic_format_string(const _Tp& __s);

      [[__gnu__::__always_inline__]]
      basic_format_string(__format::_Runtime_format_string<_CharT> __s) noexcept
      : _M_str(__s._M_str)
      { }

      [[__gnu__::__always_inline__]]
      constexpr basic_string_view<_CharT>
      get() const noexcept
      { return _M_str; }

    private:
      basic_string_view<_CharT> _M_str;
    };

  template<typename... _Args>
    using format_string = basic_format_string<char, type_identity_t<_Args>...>;


  template<typename... _Args>
    using wformat_string
      = basic_format_string<wchar_t, type_identity_t<_Args>...>;
# 216 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<typename _Tp, typename _CharT>
    struct formatter
    {
      formatter() = delete;
      formatter(const formatter&) = delete;
      formatter& operator=(const formatter&) = delete;
    };


  class format_error : public runtime_error
  {
  public:
    explicit format_error(const string& __what) : runtime_error(__what) { }
    explicit format_error(const char* __what) : runtime_error(__what) { }
  };


  [[noreturn]]
  inline void
  __throw_format_error(const char* __what)
  { (throw (format_error(__what))); }

namespace __format
{


  [[noreturn]]
  inline void
  __unmatched_left_brace_in_format_string()
  { __throw_format_error("format error: unmatched '{' in format string"); }

  [[noreturn]]
  inline void
  __unmatched_right_brace_in_format_string()
  { __throw_format_error("format error: unmatched '}' in format string"); }

  [[noreturn]]
  inline void
  __conflicting_indexing_in_format_string()
  { __throw_format_error("format error: conflicting indexing style in format string"); }

  [[noreturn]]
  inline void
  __invalid_arg_id_in_format_string()
  { __throw_format_error("format error: invalid arg-id in format string"); }

  [[noreturn]]
  inline void
  __failed_to_parse_format_spec()
  { __throw_format_error("format error: failed to parse format-spec"); }

  template<typename _CharT> class _Scanner;

}



  template<typename _CharT> class basic_format_parse_context;
  using format_parse_context = basic_format_parse_context<char>;

  using wformat_parse_context = basic_format_parse_context<wchar_t>;


  template<typename _CharT>
    class basic_format_parse_context
    {
    public:
      using char_type = _CharT;
      using const_iterator = typename basic_string_view<_CharT>::const_iterator;
      using iterator = const_iterator;

      constexpr explicit
      basic_format_parse_context(basic_string_view<_CharT> __fmt) noexcept
      : _M_begin(__fmt.begin()), _M_end(__fmt.end())
      { }

      basic_format_parse_context(const basic_format_parse_context&) = delete;
      void operator=(const basic_format_parse_context&) = delete;

      constexpr const_iterator begin() const noexcept { return _M_begin; }
      constexpr const_iterator end() const noexcept { return _M_end; }

      constexpr void
      advance_to(const_iterator __it) noexcept
      { _M_begin = __it; }

      constexpr size_t
      next_arg_id()
      {
 if (_M_indexing == _Manual)
   __format::__conflicting_indexing_in_format_string();
 _M_indexing = _Auto;



 if (std::is_constant_evaluated())
   if (_M_next_arg_id == _M_num_args)
     __format::__invalid_arg_id_in_format_string();
 return _M_next_arg_id++;
      }

      constexpr void
      check_arg_id(size_t __id)
      {
 if (_M_indexing == _Auto)
   __format::__conflicting_indexing_in_format_string();
 _M_indexing = _Manual;

 if (std::is_constant_evaluated())
   if (__id >= _M_num_args)
     __format::__invalid_arg_id_in_format_string();
      }
# 406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
      constexpr explicit
      basic_format_parse_context(basic_string_view<_CharT> __fmt,
     size_t __num_args) noexcept
      : _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)
      { }

    private:
      iterator _M_begin;
      iterator _M_end;
      enum _Indexing { _Unknown, _Manual, _Auto };
      _Indexing _M_indexing = _Unknown;
      size_t _M_next_arg_id = 0;
      size_t _M_num_args = 0;
    };


  template<typename _Tp, template<typename...> class _Class>
    constexpr bool __is_specialization_of = false;
  template<template<typename...> class _Class, typename... _Args>
    constexpr bool __is_specialization_of<_Class<_Args...>, _Class> = true;

namespace __format
{

  template<typename _CharT>
    constexpr pair<unsigned short, const _CharT*>
    __parse_integer(const _CharT* __first, const _CharT* __last)
    {
      if (__first == __last)
 __builtin_unreachable();

      if constexpr (is_same_v<_CharT, char>)
 {
   const auto __start = __first;
   unsigned short __val = 0;

   if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)
  && __first != __start) [[likely]]
     return {__val, __first};
 }
      else
 {
   constexpr int __n = 32;
   char __buf[__n]{};
   for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
     __buf[__i] = __first[__i];
   auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
   if (__ptr) [[likely]]
     return {__v, __first + (__ptr - __buf)};
 }
      return {0, nullptr};
    }

  template<typename _CharT>
    constexpr pair<unsigned short, const _CharT*>
    __parse_arg_id(const _CharT* __first, const _CharT* __last)
    {
      if (__first == __last)
 __builtin_unreachable();

      if (*__first == '0')
 return {0, __first + 1};

      if ('1' <= *__first && *__first <= '9')
 {
   const unsigned short __id = *__first - '0';
   const auto __next = __first + 1;

   if (__next == __last || !('0' <= *__next && *__next <= '9'))
     return {__id, __next};
   else
     return __format::__parse_integer(__first, __last);
 }
      return {0, nullptr};
    }

  enum _Pres_type {
    _Pres_none = 0,

    _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,

    _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,
    _Pres_p = 0, _Pres_P,
    _Pres_s = 0,
    _Pres_seq = 0, _Pres_str,
    _Pres_esc = 0xf,
  };

  enum _Align {
    _Align_default,
    _Align_left,
    _Align_right,
    _Align_centre,
  };

  enum _Sign {
    _Sign_default,
    _Sign_plus,
    _Sign_minus,
    _Sign_space,
  };

  enum _WidthPrec {
    _WP_none,
    _WP_value,
    _WP_from_arg
  };

  template<typename _Context>
    size_t
    __int_from_arg(const basic_format_arg<_Context>& __arg);

  constexpr bool __is_digit(char __c)
  { return std::__detail::__from_chars_alnum_to_val(__c) < 10; }

  constexpr bool __is_xdigit(char __c)
  { return std::__detail::__from_chars_alnum_to_val(__c) < 16; }

  template<typename _CharT>
    struct _Spec
    {
      _Align _M_align : 2;
      _Sign _M_sign : 2;
      unsigned _M_alt : 1;
      unsigned _M_localized : 1;
      unsigned _M_zero_fill : 1;
      _WidthPrec _M_width_kind : 2;
      _WidthPrec _M_prec_kind : 2;
      _Pres_type _M_type : 4;
      unsigned _M_reserved : 1;
      unsigned _M_reserved2 : 16;
      unsigned short _M_width;
      unsigned short _M_prec;
      char32_t _M_fill = ' ';

      using iterator = typename basic_string_view<_CharT>::iterator;

      static constexpr _Align
      _S_align(_CharT __c) noexcept
      {
 switch (__c)
 {
   case '<': return _Align_left;
   case '>': return _Align_right;
   case '^': return _Align_centre;
   default: return _Align_default;
 }
      }


      constexpr iterator
      _M_parse_fill_and_align(iterator __first, iterator __last) noexcept
      { return _M_parse_fill_and_align(__first, __last, "{"); }


      constexpr iterator
      _M_parse_fill_and_align(iterator __first, iterator __last, string_view __not_fill) noexcept
      {
 for (char __c : __not_fill)
   if (*__first == static_cast<_CharT>(__c))
     return __first;

 using namespace __unicode;
 if constexpr (__literal_encoding_is_unicode<_CharT>())
   {

     _Utf32_view<ranges::subrange<iterator>> __uv({__first, __last});
     if (!__uv.empty())
     {
       auto __beg = __uv.begin();
       char32_t __c = *__beg++;
       if (__is_scalar_value(__c))
  if (auto __next = __beg.base(); __next != __last)
    if (_Align __align = _S_align(*__next))
      {
        _M_fill = __c;
        _M_align = __align;
        return ++__next;
      }
      }
   }
 else if (__last - __first >= 2)
   if (_Align __align = _S_align(__first[1]))
     {
       _M_fill = *__first;
       _M_align = __align;
       return __first + 2;
     }

 if (_Align __align = _S_align(__first[0]))
   {
     _M_fill = ' ';
     _M_align = __align;
     return __first + 1;
   }
 return __first;
      }

      static constexpr _Sign
      _S_sign(_CharT __c) noexcept
      {
 switch (__c)
 {
   case '+': return _Sign_plus;
   case '-': return _Sign_minus;
   case ' ': return _Sign_space;
   default: return _Sign_default;
 }
      }


      constexpr iterator
      _M_parse_sign(iterator __first, iterator) noexcept
      {
 if (_Sign __sign = _S_sign(*__first))
   {
     _M_sign = __sign;
     return __first + 1;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_alternate_form(iterator __first, iterator) noexcept
      {
 if (*__first == '#')
   {
     _M_alt = true;
     ++__first;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_zero_fill(iterator __first, iterator ) noexcept
      {
 if (*__first == '0')
   {
     _M_zero_fill = true;
     ++__first;
   }
 return __first;
      }


      static constexpr iterator
      _S_parse_width_or_precision(iterator __first, iterator __last,
      unsigned short& __val, bool& __arg_id,
      basic_format_parse_context<_CharT>& __pc)
      {
 if (__format::__is_digit(*__first))
   {
     auto [__v, __ptr] = __format::__parse_integer(__first, __last);
     if (!__ptr)
       __throw_format_error("format error: invalid width or precision "
       "in format-spec");
     __first = __ptr;
     __val = __v;
   }
 else if (*__first == '{')
   {
     __arg_id = true;
     ++__first;
     if (__first == __last)
       __format::__unmatched_left_brace_in_format_string();
     if (*__first == '}')
       __val = __pc.next_arg_id();
     else
       {
  auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
  if (__ptr == nullptr || __ptr == __last || *__ptr != '}')
    __format::__invalid_arg_id_in_format_string();
  __first = __ptr;
  __pc.check_arg_id(__v);
  __val = __v;
       }



     ++__first;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_width(iterator __first, iterator __last,
       basic_format_parse_context<_CharT>& __pc)
      {
 bool __arg_id = false;
 if (*__first == '0')
   __throw_format_error("format error: width must be non-zero in "
          "format string");
 auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
        __arg_id, __pc);
 if (__next != __first)
   _M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
 return __next;
      }


      constexpr iterator
      _M_parse_precision(iterator __first, iterator __last,
    basic_format_parse_context<_CharT>& __pc)
      {
 if (__first[0] != '.')
   return __first;

 iterator __next = ++__first;
 bool __arg_id = false;
 if (__next != __last)
   __next = _S_parse_width_or_precision(__first, __last, _M_prec,
            __arg_id, __pc);
 if (__next == __first)
   __throw_format_error("format error: missing precision after '.' in "
          "format string");
 _M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
 return __next;
      }


      constexpr iterator
      _M_parse_locale(iterator __first, iterator ) noexcept
      {
 if (*__first == 'L')
   {
     _M_localized = true;
     ++__first;
   }
 return __first;
      }

      template<typename _Context>
 size_t
 _M_get_width(_Context& __ctx) const
 {
   size_t __width = 0;
   if (_M_width_kind == _WP_value)
     __width = _M_width;
   else if (_M_width_kind == _WP_from_arg)
     __width = __format::__int_from_arg(__ctx.arg(_M_width));
   return __width;
 }

      template<typename _Context>
 size_t
 _M_get_precision(_Context& __ctx) const
 {
   size_t __prec = -1;
   if (_M_prec_kind == _WP_value)
     __prec = _M_prec;
   else if (_M_prec_kind == _WP_from_arg)
     __prec = __format::__int_from_arg(__ctx.arg(_M_prec));
   return __prec;
 }
    };

  template<typename _Int>
    inline char*
    __put_sign(_Int __i, _Sign __sign, char* __dest) noexcept
    {
      if (__i < 0)
 *__dest = '-';
      else if (__sign == _Sign_plus)
 *__dest = '+';
      else if (__sign == _Sign_space)
 *__dest = ' ';
      else
 ++__dest;
      return __dest;
    }


  template<typename _Out, typename _CharT>
    requires output_iterator<_Out, const _CharT&>
    inline _Out
    __write(_Out __out, basic_string_view<_CharT> __str)
    {
      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 {
   if (__str.size())
     __out = __str;
 }
      else
 for (_CharT __c : __str)
   *__out++ = __c;
      return __out;
    }



  template<typename _Out, typename _CharT>
    _Out
    __write_padded(_Out __out, basic_string_view<_CharT> __str,
     _Align __align, size_t __nfill, char32_t __fill_char)
    {
      const size_t __buflen = 0x20;
      _CharT __padding_chars[__buflen];
      __padding_chars[0] = _CharT();
      basic_string_view<_CharT> __padding{__padding_chars, __buflen};

      auto __pad = [&__padding] (size_t __n, _Out& __o) {
 if (__n == 0)
   return;
 while (__n > __padding.size())
   {
     __o = __format::__write(std::move(__o), __padding);
     __n -= __padding.size();
   }
 if (__n != 0)
   __o = __format::__write(std::move(__o), __padding.substr(0, __n));
      };

      size_t __l, __r, __max;
      if (__align == _Align_centre)
 {
   __l = __nfill / 2;
   __r = __l + (__nfill & 1);
   __max = __r;
 }
      else if (__align == _Align_right)
 {
   __l = __nfill;
   __r = 0;
   __max = __l;
 }
      else
 {
   __l = 0;
   __r = __nfill;
   __max = __r;
 }

      using namespace __unicode;
      if constexpr (__literal_encoding_is_unicode<_CharT>())
 if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]
   {

     const char32_t __arr[1]{ __fill_char };
     _Utf_view<_CharT, const char32_t(&)[1]> __v(__arr);
     basic_string<_CharT> __padstr(__v.begin(), __v.end());
     __padding = __padstr;
     while (__l-- > 0)
       __out = __format::__write(std::move(__out), __padding);
     __out = __format::__write(std::move(__out), __str);
     while (__r-- > 0)
       __out = __format::__write(std::move(__out), __padding);
     return __out;
   }

      if (__max < __buflen)
 __padding.remove_suffix(__buflen - __max);
      else
 __max = __buflen;

      char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
      __pad(__l, __out);
      __out = __format::__write(std::move(__out), __str);
      __pad(__r, __out);

      return __out;
    }



  template<typename _CharT, typename _Out>
    _Out
    __write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
      size_t __estimated_width,
      basic_format_context<_Out, _CharT>& __fc,
      const _Spec<_CharT>& __spec,
      _Align __align = _Align_left)
    {
      size_t __width = __spec._M_get_width(__fc);

      if (__width <= __estimated_width)
 return __format::__write(__fc.out(), __str);

      const size_t __nfill = __width - __estimated_width;

      if (__spec._M_align)
 __align = __spec._M_align;

      return __format::__write_padded(__fc.out(), __str, __align, __nfill,
          __spec._M_fill);
    }


  enum class _Term_char : unsigned char {
    _Tc_quote = 12,
    _Tc_apos = 15
  };

  template<typename _CharT>
    struct _Escapes
    {
      using _Str_view = basic_string_view<_CharT>;

      static consteval
      _Str_view _S_all()
      { return ::std::__format::_Widen<_CharT>("\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x", L"\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x"); }

      static constexpr
      _CharT _S_term(_Term_char __term)
      { return _S_all()[static_cast<unsigned char>(__term)]; }

      static consteval
      _Str_view _S_tab()
      { return _S_all().substr(0, 3); }

      static consteval
      _Str_view _S_newline()
      { return _S_all().substr(3, 3); }

      static consteval
      _Str_view _S_return()
      { return _S_all().substr(6, 3); }

      static consteval
      _Str_view _S_bslash()
      { return _S_all().substr(9, 3); }

      static consteval
      _Str_view _S_quote()
      { return _S_all().substr(12, 3); }

      static consteval
      _Str_view _S_apos()
      { return _S_all().substr(15, 3); }

      static consteval
      _Str_view _S_u()
      { return _S_all().substr(18, 2); }

      static consteval
      _Str_view _S_x()
      { return _S_all().substr(20, 2); }
    };

  template<typename _CharT>
    struct _Separators
    {
      using _Str_view = basic_string_view<_CharT>;

      static consteval
      _Str_view _S_all()
      { return ::std::__format::_Widen<_CharT>("[]{}(), : ", L"[]{}(), : "); }

      static consteval
      _Str_view _S_squares()
      { return _S_all().substr(0, 2); }

      static consteval
      _Str_view _S_braces()
      { return _S_all().substr(2, 2); }

      static consteval
      _Str_view _S_parens()
      { return _S_all().substr(4, 2); }

      static consteval
      _Str_view _S_comma()
      { return _S_all().substr(6, 2); }

      static consteval
      _Str_view _S_colon()
      { return _S_all().substr(8, 2); }
    };

  template<typename _CharT>
    constexpr bool __should_escape_ascii(_CharT __c, _Term_char __term)
    {
      using _Esc = _Escapes<_CharT>;
      switch (__c)
 {
   case _Esc::_S_tab()[0]:
   case _Esc::_S_newline()[0]:
   case _Esc::_S_return()[0]:
   case _Esc::_S_bslash()[0]:
     return true;
   case _Esc::_S_quote()[0]:
     return __term == _Term_char::_Tc_quote;
   case _Esc::_S_apos()[0]:
     return __term == _Term_char::_Tc_apos;
   default:
     return (__c >= 0 && __c < 0x20) || __c == 0x7f;
 };
  }


  constexpr bool __should_escape_unicode(char32_t __c, bool __prev_esc)
  {
    if (__unicode::__should_escape_category(__c))
      return __c != U' ';
    if (!__prev_esc)
      return false;
    return __unicode::__grapheme_cluster_break_property(__c)
      == __unicode::_Gcb_property::_Gcb_Extend;
  }

  using uint_least32_t = unsigned int;
  template<typename _Out, typename _CharT>
    _Out
    __write_escape_seq(_Out __out, uint_least32_t __val,
         basic_string_view<_CharT> __prefix)
    {
      using _Str_view = basic_string_view<_CharT>;
      constexpr size_t __max = 8;
      char __buf[__max];
      const string_view __narrow(
 __buf,
 std::__to_chars_i<uint_least32_t>(__buf, __buf + __max, __val, 16).ptr);

      __out = __format::__write(__out, __prefix);
      *__out = _Separators<_CharT>::_S_braces()[0];
      ++__out;
      if constexpr (is_same_v<char, _CharT>)
 __out = __format::__write(__out, __narrow);

      else
 {
   _CharT __wbuf[__max];
   const size_t __n = __narrow.size();
   std::__to_wstring_numeric(__narrow.data(), __n, __wbuf);
   __out = __format::__write(__out, _Str_view(__wbuf, __n));
 }

      *__out = _Separators<_CharT>::_S_braces()[1];
      return ++__out;
    }

  template<typename _Out, typename _CharT>
    _Out
    __write_escaped_char(_Out __out, _CharT __c)
    {
      using _UChar = make_unsigned_t<_CharT>;
      using _Esc = _Escapes<_CharT>;
      switch (__c)
 {
   case _Esc::_S_tab()[0]:
     return __format::__write(__out, _Esc::_S_tab().substr(1, 2));
   case _Esc::_S_newline()[0]:
     return __format::__write(__out, _Esc::_S_newline().substr(1, 2));
   case _Esc::_S_return()[0]:
     return __format::__write(__out, _Esc::_S_return().substr(1, 2));
   case _Esc::_S_bslash()[0]:
     return __format::__write(__out, _Esc::_S_bslash().substr(1, 2));
   case _Esc::_S_quote()[0]:
     return __format::__write(__out, _Esc::_S_quote().substr(1, 2));
   case _Esc::_S_apos()[0]:
     return __format::__write(__out, _Esc::_S_apos().substr(1, 2));
   default:
     return __format::__write_escape_seq(__out,
    static_cast<_UChar>(__c),
      _Esc::_S_u());
 }
    }

  template<typename _CharT, typename _Out>
    _Out
    __write_escaped_ascii(_Out __out,
     basic_string_view<_CharT> __str,
     _Term_char __term)
    {
      using _Str_view = basic_string_view<_CharT>;
      auto __first = __str.begin();
      auto const __last = __str.end();
      while (__first != __last)
      {
 auto __print = __first;

 while (__print != __last
   && !__format::__should_escape_ascii(*__print, __term))
   ++__print;

 if (__print != __first)
   __out = __format::__write(__out, _Str_view(__first, __print));

 if (__print == __last)
   return __out;

 __first = __print;
 __out = __format::__write_escaped_char(__out, *__first);
 ++__first;
      }
      return __out;
    }

  template<typename _CharT, typename _Out>
    _Out
    __write_escaped_unicode(_Out __out,
       basic_string_view<_CharT> __str,
       _Term_char __term)
    {
      using _Str_view = basic_string_view<_CharT>;
      using _UChar = make_unsigned_t<_CharT>;
      using _Esc = _Escapes<_CharT>;

      static constexpr char32_t __replace = U'\uFFFD';
      static constexpr _Str_view __replace_rep = []
 {

   if constexpr (is_same_v<char, _CharT>)
     return "\xEF\xBF\xBD";
   else
     return L"\xFFFD";
 }();

      __unicode::_Utf_view<char32_t, _Str_view> __v(std::move(__str));
      auto __first = __v.begin();
      auto const __last = __v.end();

      bool __prev_esc = true;
      while (__first != __last)
 {
   bool __esc_ascii = false;
   bool __esc_unicode = false;
   bool __esc_replace = false;
   auto __should_escape = [&](auto const& __it)
     {
       if (*__it <= 0x7f)
  return __esc_ascii
    = __format::__should_escape_ascii(*__it.base(), __term);
       if (__format::__should_escape_unicode(*__it, __prev_esc))
  return __esc_unicode = true;
       if (*__it == __replace)
  {
    _Str_view __units(__it.base(), __it._M_units());
    return __esc_replace = (__units != __replace_rep);
  }
       return false;
     };

   auto __print = __first;
   while (__print != __last && !__should_escape(__print))
     {
       __prev_esc = false;
       ++__print;
     }

   if (__print != __first)
     __out = __format::__write(__out, _Str_view(__first.base(), __print.base()));

   if (__print == __last)
     return __out;

   __first = __print;
   if (__esc_ascii)
     __out = __format::__write_escaped_char(__out, *__first.base());
   else if (__esc_unicode)
     __out = __format::__write_escape_seq(__out, *__first, _Esc::_S_u());
   else
     for (_CharT __c : _Str_view(__first.base(), __first._M_units()))
       __out = __format::__write_escape_seq(__out,
         static_cast<_UChar>(__c),
         _Esc::_S_x());
   __prev_esc = true;
   ++__first;

 }
      return __out;
    }

  template<typename _CharT, typename _Out>
    _Out
    __write_escaped(_Out __out, basic_string_view<_CharT> __str, _Term_char __term)
    {
      *__out = _Escapes<_CharT>::_S_term(__term);
      ++__out;

      if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
 __out = __format::__write_escaped_unicode(__out, __str, __term);
      else if constexpr (is_same_v<char, _CharT>
     && __unicode::__literal_encoding_is_extended_ascii())
 __out = __format::__write_escaped_ascii(__out, __str, __term);
      else

 __out = __format::__write_escaped_ascii(__out, __str, __term);

      *__out = _Escapes<_CharT>::_S_term(__term);
      return ++__out;
    }


  struct _Optional_locale
  {
    [[__gnu__::__always_inline__]]
    _Optional_locale() : _M_dummy(), _M_hasval(false) { }

    _Optional_locale(const locale& __loc) noexcept
    : _M_loc(__loc), _M_hasval(true)
    { }

    _Optional_locale(const _Optional_locale& __l) noexcept
    : _M_dummy(), _M_hasval(__l._M_hasval)
    {
      if (_M_hasval)
 std::construct_at(&_M_loc, __l._M_loc);
    }

    _Optional_locale&
    operator=(const _Optional_locale& __l) noexcept
    {
      if (_M_hasval)
 {
   if (__l._M_hasval)
     _M_loc = __l._M_loc;
   else
     {
       _M_loc.~locale();
       _M_hasval = false;
     }
 }
      else if (__l._M_hasval)
 {
   std::construct_at(&_M_loc, __l._M_loc);
   _M_hasval = true;
 }
      return *this;
    }

    ~_Optional_locale() { if (_M_hasval) _M_loc.~locale(); }

    _Optional_locale&
    operator=(locale&& __loc) noexcept
    {
      if (_M_hasval)
 _M_loc = std::move(__loc);
      else
 {
   std::construct_at(&_M_loc, std::move(__loc));
   _M_hasval = true;
 }
      return *this;
    }

    const locale&
    value() noexcept
    {
      if (!_M_hasval)
 {
   std::construct_at(&_M_loc);
   _M_hasval = true;
 }
      return _M_loc;
    }

    bool has_value() const noexcept { return _M_hasval; }

    union {
      char _M_dummy = '\0';
      std::locale _M_loc;
    };
    bool _M_hasval = false;
  };

  template<__char _CharT>
    struct __formatter_str
    {
      __formatter_str() = default;

      constexpr
      __formatter_str(_Spec<_CharT> __spec) noexcept
       : _M_spec(__spec)
      { }

      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 auto __first = __pc.begin();
 const auto __last = __pc.end();
 _Spec<_CharT> __spec{};

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_width(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_precision(__first, __last, __pc);
 if (__finished())
   return __first;

 if (*__first == 's')
   ++__first;
# 1319 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Out>
 _Out
 format(basic_string_view<_CharT> __s,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   constexpr auto __term = __format::_Term_char::_Tc_quote;
   const auto __write_direct = [&]
     {
       if (_M_spec._M_type == _Pres_esc)
  return __format::__write_escaped(__fc.out(), __s, __term);
       else
  return __format::__write(__fc.out(), __s);
     };

   if (_M_spec._M_width_kind == _WP_none
  && _M_spec._M_prec_kind == _WP_none)
     return __write_direct();

   const size_t __prec =
     _M_spec._M_prec_kind != _WP_none
       ? _M_spec._M_get_precision(__fc)
       : basic_string_view<_CharT>::npos;

   const size_t __estimated_width = _S_trunc(__s, __prec);

   if (_M_spec._M_get_width(__fc) <= __estimated_width
  && _M_spec._M_prec_kind == _WP_none)
      return __write_direct();

   if (_M_spec._M_type != _Pres_esc)
     return __format::__write_padded_as_spec(__s, __estimated_width,
          __fc, _M_spec);

   __format::_Str_sink<_CharT> __sink;
   __format::__write_escaped(__sink.out(), __s, __term);
   basic_string_view<_CharT> __escaped(__sink.view().data(),
           __sink.view().size());
   const size_t __escaped_width = _S_trunc(__escaped, __prec);



   return __format::__write_padded_as_spec(__escaped, __escaped_width,
        __fc, _M_spec);
 }
# 1413 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
    private:
      static size_t
      _S_trunc(basic_string_view<_CharT>& __s, size_t __prec)
      {
 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
  {
    if (__prec != basic_string_view<_CharT>::npos)
      return __unicode::__truncate(__s, __prec);
    else
      return __unicode::__field_width(__s);
  }
       else
 {
   __s = __s.substr(0, __prec);
   return __s.size();
 }
      }

      _Spec<_CharT> _M_spec{};
    };

  template<__char _CharT>
    struct __formatter_int
    {


      static constexpr _Pres_type _AsInteger = _Pres_d;
      static constexpr _Pres_type _AsBool = _Pres_s;
      static constexpr _Pres_type _AsChar = _Pres_c;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      _M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
      {
 _Spec<_CharT> __spec{};
 __spec._M_type = __type;

 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_sign(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_alternate_form(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_width(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_locale(__first, __last);
 if (__finished())
   return __first;

 switch (*__first)
 {
   case 'b':
     __spec._M_type = _Pres_b;
     ++__first;
     break;
   case 'B':
     __spec._M_type = _Pres_B;
     ++__first;
     break;
   case 'c':


     if (__type != _AsBool)
       {
  __spec._M_type = _Pres_c;
  ++__first;
       }
     break;
   case 'd':
     __spec._M_type = _Pres_d;
     ++__first;
     break;
   case 'o':
     __spec._M_type = _Pres_o;
     ++__first;
     break;
   case 'x':
     __spec._M_type = _Pres_x;
     ++__first;
     break;
   case 'X':
     __spec._M_type = _Pres_X;
     ++__first;
     break;
   case 's':
     if (__type == _AsBool)
       {
  __spec._M_type = _Pres_s;
  ++__first;
       }
     break;
# 1542 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
     break;
   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Tp>
 constexpr typename basic_format_parse_context<_CharT>::iterator
 _M_parse(basic_format_parse_context<_CharT>& __pc)
 {
   if constexpr (is_same_v<_Tp, bool>)
     {
       auto __end = _M_do_parse(__pc, _AsBool);
       if (_M_spec._M_type == _Pres_s)
  if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill)
    __throw_format_error("format error: format-spec contains "
           "invalid formatting options for "
           "'bool'");
       return __end;
     }
   else if constexpr (__char<_Tp>)
     {
       auto __end = _M_do_parse(__pc, _AsChar);
       if (_M_spec._M_type == _Pres_c || _M_spec._M_type == _Pres_esc)
  if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill
                                                            )
    __throw_format_error("format error: format-spec contains "
           "invalid formatting options for "
           "'charT'");
       return __end;
     }
   else
     return _M_do_parse(__pc, _AsInteger);
 }

      template<typename _Int, typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Int __i, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_spec._M_type == _Pres_c)
     return _M_format_character(_S_to_character(__i), __fc);

   char __buf[sizeof(_Int) * 8 + 3];
   to_chars_result __res{};

   string_view __base_prefix;
   make_unsigned_t<_Int> __u;
   if (__i < 0)
     __u = -static_cast<make_unsigned_t<_Int>>(__i);
   else
     __u = __i;

   char* __start = __buf + 3;
   char* const __end = __buf + sizeof(__buf);
   char* const __start_digits = __start;

   switch (_M_spec._M_type)
   {
     case _Pres_b:
     case _Pres_B:
       __base_prefix = _M_spec._M_type == _Pres_b ? "0b" : "0B";
       __res = to_chars(__start, __end, __u, 2);
       break;




     case _Pres_none:

       [[fallthrough]];
     case _Pres_d:
       __res = to_chars(__start, __end, __u, 10);
       break;
     case _Pres_o:
       if (__i != 0)
  __base_prefix = "0";
       __res = to_chars(__start, __end, __u, 8);
       break;
     case _Pres_x:
     case _Pres_X:
       __base_prefix = _M_spec._M_type == _Pres_x ? "0x" : "0X";
       __res = to_chars(__start, __end, __u, 16);
       if (_M_spec._M_type == _Pres_X)
  for (auto __p = __start; __p != __res.ptr; ++__p)



    *__p = std::toupper(*__p);

       break;
     default:
       __builtin_unreachable();
   }

   if (_M_spec._M_alt && __base_prefix.size())
     {
       __start -= __base_prefix.size();
       __builtin_memcpy(__start, __base_prefix.data(),
          __base_prefix.size());
     }
   __start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);

   return _M_format_int(string_view(__start, __res.ptr - __start),
          __start_digits - __start, __fc);
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(bool __i, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_spec._M_type == _Pres_c)
     return _M_format_character(static_cast<unsigned char>(__i), __fc);
   if (_M_spec._M_type != _Pres_s)
     return format(static_cast<unsigned char>(__i), __fc);

   basic_string<_CharT> __s;
   size_t __est_width;
   if (_M_spec._M_localized) [[unlikely]]
     {
       auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
       __s = __i ? __np.truename() : __np.falsename();
       __est_width = __s.size();
     }
   else
     {
       if constexpr (is_same_v<char, _CharT>)
  __s = __i ? "true" : "false";
       else
  __s = __i ? L"true" : L"false";
       __est_width = __s.size();
     }

   return __format::__write_padded_as_spec(__s, __est_width, __fc,
        _M_spec);
 }

      [[__gnu__::__always_inline__]]
      static size_t
      _S_character_width(_CharT __c)
      {

 if constexpr (sizeof(_CharT) > 1u &&
   __unicode::__literal_encoding_is_unicode<_CharT>())
   return __unicode::__field_width(__c);
 else
   return 1u;
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 _M_format_character(_CharT __c,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   return __format::__write_padded_as_spec({&__c, 1u},
        _S_character_width(__c),
        __fc, _M_spec);
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 _M_format_character_escaped(_CharT __c,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   using _Esc = _Escapes<_CharT>;
   constexpr auto __term = __format::_Term_char::_Tc_apos;
   const basic_string_view<_CharT> __in(&__c, 1u);
   if (_M_spec._M_get_width(__fc) <= 3u)
     return __format::__write_escaped(__fc.out(), __in, __term);

   _CharT __buf[12];
   __format::_Fixedbuf_sink<_CharT> __sink(__buf);
   __format::__write_escaped(__sink.out(), __in, __term);

   const basic_string_view<_CharT> __escaped = __sink.view();
   size_t __estimated_width;
   if (__escaped[1] == _Esc::_S_bslash()[0])
     __estimated_width = __escaped.size();
   else
     __estimated_width = 2 + _S_character_width(__c);
   return __format::__write_padded_as_spec(__escaped,
        __estimated_width,
        __fc, _M_spec);
 }

      template<typename _Int>
 static _CharT
 _S_to_character(_Int __i)
 {
   using _Traits = __gnu_cxx::__int_traits<_CharT>;
   if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
     {
       if (_Traits::__min <= __i && __i <= _Traits::__max)
  return static_cast<_CharT>(__i);
     }
   else if constexpr (is_signed_v<_Int>)
     {
       if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
  return static_cast<_CharT>(__i);
     }
   else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
     return static_cast<_CharT>(__i);
   __throw_format_error("format error: integer not representable as "
          "character");
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 _M_format_int(string_view __narrow_str, size_t __prefix_len,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   size_t __width = _M_spec._M_get_width(__fc);

   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<char, _CharT>)
     __str = __narrow_str;

   else
     {
       size_t __n = __narrow_str.size();
       auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
       std::__to_wstring_numeric(__narrow_str.data(), __n, __p);
       __str = {__p, __n};
     }


   if (_M_spec._M_localized)
     {
       const auto& __l = __fc.locale();
       if (__l.name() != "C")
  {
    auto& __np = use_facet<numpunct<_CharT>>(__l);
    string __grp = __np.grouping();
    if (!__grp.empty())
      {
        size_t __n = __str.size() - __prefix_len;
        auto __p = (_CharT*)__builtin_alloca(2 * __n
            * sizeof(_CharT)
            + __prefix_len);
        auto __s = __str.data();
        char_traits<_CharT>::copy(__p, __s, __prefix_len);
        __s += __prefix_len;
        auto __end = std::__add_grouping(__p + __prefix_len,
             __np.thousands_sep(),
             __grp.data(),
             __grp.size(),
             __s, __s + __n);
        __str = {__p, size_t(__end - __p)};
      }
  }
     }

   if (__width <= __str.size())
     return __format::__write(__fc.out(), __str);

   char32_t __fill_char = _M_spec._M_fill;
   _Align __align = _M_spec._M_align;

   size_t __nfill = __width - __str.size();
   auto __out = __fc.out();
   if (__align == _Align_default)
     {
       __align = _Align_right;
       if (_M_spec._M_zero_fill)
  {
    __fill_char = _CharT('0');

    if (__prefix_len != 0)
      {
        __out = __format::__write(std::move(__out),
      __str.substr(0, __prefix_len));
        __str.remove_prefix(__prefix_len);
      }
  }
       else
  __fill_char = _CharT(' ');
     }
   return __format::__write_padded(std::move(__out), __str,
       __align, __nfill, __fill_char);
 }


      template<typename _Tp>
 using make_unsigned_t
   = typename __conditional_t<(sizeof(_Tp) <= sizeof(long long)),
         std::make_unsigned<_Tp>,
         type_identity<unsigned __int128>>::type;


      template<typename _Int>
 static to_chars_result
 to_chars(char* __first, char* __last, _Int __value, int __base)
 { return std::__to_chars_i<_Int>(__first, __last, __value, __base); }


      _Spec<_CharT> _M_spec{};
    };
# 1927 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  using std::to_chars;


  template<typename _Tp>
    concept __formattable_float
      = is_same_v<remove_cv_t<_Tp>, _Tp> && requires (_Tp __t, char* __p)
      { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };

  template<__char _CharT>
    struct __formatter_fp
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 _Spec<_CharT> __spec{};
 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_sign(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_alternate_form(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;

 if (__first[0] != '.')
   {
     __first = __spec._M_parse_width(__first, __last, __pc);
     if (__finished())
       return __first;
   }

 __first = __spec._M_parse_precision(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_locale(__first, __last);
 if (__finished())
   return __first;

 switch (*__first)
 {
   case 'a':
     __spec._M_type = _Pres_a;
     ++__first;
     break;
   case 'A':
     __spec._M_type = _Pres_A;
     ++__first;
     break;
   case 'e':
     __spec._M_type = _Pres_e;
     ++__first;
     break;
   case 'E':
     __spec._M_type = _Pres_E;
     ++__first;
     break;
   case 'f':
     __spec._M_type = _Pres_f;
     ++__first;
     break;
   case 'F':
     __spec._M_type = _Pres_F;
     ++__first;
     break;
   case 'g':
     __spec._M_type = _Pres_g;
     ++__first;
     break;
   case 'G':
     __spec._M_type = _Pres_G;
     ++__first;
     break;
   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Fp, typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
 {
   std::string __dynbuf;
   char __buf[128];
   to_chars_result __res{};

   size_t __prec = 6;
   bool __use_prec = _M_spec._M_prec_kind != _WP_none;
   if (__use_prec)
     __prec = _M_spec._M_get_precision(__fc);

   char* __start = __buf + 1;
   char* __end = __buf + sizeof(__buf);

   chars_format __fmt{};
   bool __upper = false;
   bool __trailing_zeros = false;
   char __expc = 'e';

   switch (_M_spec._M_type)
   {
     case _Pres_A:
       __upper = true;
       __expc = 'P';
       [[fallthrough]];
     case _Pres_a:
       if (_M_spec._M_type != _Pres_A)
  __expc = 'p';
       __fmt = chars_format::hex;
       break;
     case _Pres_E:
       __upper = true;
       __expc = 'E';
       [[fallthrough]];
     case _Pres_e:
       __use_prec = true;
       __fmt = chars_format::scientific;
       break;
     case _Pres_F:
       __upper = true;
       [[fallthrough]];
     case _Pres_f:
       __use_prec = true;
       __fmt = chars_format::fixed;
       break;
     case _Pres_G:
       __upper = true;
       __expc = 'E';
       [[fallthrough]];
     case _Pres_g:
       __trailing_zeros = true;
       __use_prec = true;
       __fmt = chars_format::general;
       break;
     case _Pres_none:
       if (__use_prec)
  __fmt = chars_format::general;
       break;
     default:
       __builtin_unreachable();
   }


   auto __to_chars = [&](char* __b, char* __e) {
     if (__use_prec)
       return __format::to_chars(__b, __e, __v, __fmt, __prec);
     else if (__fmt != chars_format{})
       return __format::to_chars(__b, __e, __v, __fmt);
     else
       return __format::to_chars(__b, __e, __v);
   };


   __res = __to_chars(__start, __end);

   if (__builtin_expect(__res.ec == errc::value_too_large, 0))
     {


       size_t __guess = 8 + __prec;
       if (__fmt == chars_format::fixed)
  {
    if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
      || is_same_v<_Fp, long double>)
      {


        int __exp{};
        if constexpr (is_same_v<_Fp, float>)
   __builtin_frexpf(__v, &__exp);
        else if constexpr (is_same_v<_Fp, double>)
   __builtin_frexp(__v, &__exp);
        else if constexpr (is_same_v<_Fp, long double>)
   __builtin_frexpl(__v, &__exp);
        if (__exp > 0)
   __guess += 1U + __exp * 4004U / 13301U;
      }
    else
      __guess += numeric_limits<_Fp>::max_exponent10;
  }
       if (__guess <= sizeof(__buf)) [[unlikely]]
  __guess = sizeof(__buf) * 2;
       __dynbuf.reserve(__guess);

       do
  {




    auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
    {
      __res = __to_chars(__p + 1, __p + __n - 1);
      return __res.ec == errc{} ? __res.ptr - __p : 0;
    };

    __dynbuf.__resize_and_overwrite(__dynbuf.capacity() * 2,
        __overwrite);
    __start = __dynbuf.data() + 1;
    __end = __dynbuf.data() + __dynbuf.size();
  }
       while (__builtin_expect(__res.ec == errc::value_too_large, 0));
   }


   if (__upper)
     {
       for (char* __p = __start; __p != __res.ptr; ++__p)
  *__p = std::toupper(*__p);
     }

   bool __have_sign = true;

   if (!__builtin_signbit(__v))
     {
       if (_M_spec._M_sign == _Sign_plus)
  *--__start = '+';
       else if (_M_spec._M_sign == _Sign_space)
  *--__start = ' ';
       else
  __have_sign = false;
     }

   string_view __narrow_str(__start, __res.ptr - __start);



   if (_M_spec._M_alt && __builtin_isfinite(__v))
     {
       string_view __s = __narrow_str;
       size_t __sigfigs;
       size_t __z = 0;
       size_t __p;
       size_t __d = __s.find('.');
       if (__d != __s.npos)
  {
    __p = __s.find(__expc, __d + 1);
    if (__p == __s.npos)
      __p = __s.size();


    if (__trailing_zeros)
      {

        if (__s[__have_sign] != '0')

   __sigfigs = __p - __have_sign - 1;
        else



   __sigfigs = __p - __s.find_first_not_of('0', __d + 1);
      }
  }
       else
  {
    __p = __s.find(__expc);
    if (__p == __s.npos)
      __p = __s.size();
    __d = __p;
    __sigfigs = __d - __have_sign;
  }

       if (__trailing_zeros && __prec != 0)
  {



    __z = __prec - __sigfigs;
  }

       if (size_t __extras = int(__d == __p) + __z)
  {
    if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
      {


        __builtin_memmove(__start + __p + __extras,
     __start + __p,
     __s.size() - __p);
        if (__d == __p)
   __start[__p++] = '.';
        __builtin_memset(__start + __p, '0', __z);
        __narrow_str = {__s.data(), __s.size() + __extras};
      }
    else
      {
        __dynbuf.reserve(__s.size() + __extras);
        if (__dynbuf.empty())
   {
     __dynbuf = __s.substr(0, __p);
     if (__d == __p)
       __dynbuf += '.';
     if (__z)
       __dynbuf.append(__z, '0');
     __dynbuf.append(__s.substr(__p));
   }
        else
   {
     __dynbuf.insert(__p, __extras, '0');
     if (__d == __p)
       __dynbuf[__p] = '.';
   }
        __narrow_str = __dynbuf;
      }
  }
     }

   basic_string<_CharT> __wstr;
   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<_CharT, char>)
     __str = __narrow_str;

   else
     {
       __wstr = std::__to_wstring_numeric(__narrow_str);
       __str = __wstr;
     }


   if (_M_spec._M_localized && __builtin_isfinite(__v))
     {
       auto __s = _M_localize(__str, __expc, __fc.locale());
       if (!__s.empty())
  __str = __wstr = std::move(__s);
     }

   size_t __width = _M_spec._M_get_width(__fc);

   if (__width <= __str.size())
     return __format::__write(__fc.out(), __str);

   char32_t __fill_char = _M_spec._M_fill;
   _Align __align = _M_spec._M_align;

   size_t __nfill = __width - __str.size();
   auto __out = __fc.out();
   if (__align == _Align_default)
     {
       __align = _Align_right;
       if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
  {
    __fill_char = _CharT('0');

    if (!__format::__is_xdigit(__narrow_str[0]))
      {
        *__out++ = __str[0];
        __str.remove_prefix(1);
      }
  }
       else
  __fill_char = _CharT(' ');
     }
   return __format::__write_padded(std::move(__out), __str,
       __align, __nfill, __fill_char);
 }


      basic_string<_CharT>
      _M_localize(basic_string_view<_CharT> __str, char __expc,
    const locale& __loc) const
      {
 basic_string<_CharT> __lstr;

 if (__loc == locale::classic())
   return __lstr;

 const auto& __np = use_facet<numpunct<_CharT>>(__loc);
 const _CharT __point = __np.decimal_point();
 const string __grp = __np.grouping();

 _CharT __dot, __exp;
 if constexpr (is_same_v<_CharT, char>)
   {
     __dot = '.';
     __exp = __expc;
   }
 else
   {
     __dot = L'.';
     switch (__expc)
     {
       case 'e':
  __exp = L'e';
  break;
       case 'E':
  __exp = L'E';
  break;
       case 'p':
  __exp = L'p';
  break;
       case 'P':
  __exp = L'P';
  break;
       default:
  __builtin_unreachable();
     }
   }

 if (__grp.empty() && __point == __dot)
   return __lstr;

 size_t __d = __str.find(__dot);
 size_t __e = min(__d, __str.find(__exp));
 if (__e == __str.npos)
   __e = __str.size();
 const size_t __r = __str.size() - __e;
 auto __overwrite = [&](_CharT* __p, size_t) {

   int __off = 0;
   if (auto __c = __str.front(); __c == '-' || __c == '+' || __c == ' ')
     {
       *__p = __c;
       __off = 1;
     }
   auto __end = std::__add_grouping(__p + __off, __np.thousands_sep(),
        __grp.data(), __grp.size(),
        __str.data() + __off,
        __str.data() + __e);
   if (__r)
     {
       if (__d != __str.npos)
  {
    *__end = __point;
    ++__end;
    ++__e;
  }
       const size_t __rlen = __str.size() - __e;

       char_traits<_CharT>::copy(__end, __str.data() + __e, __rlen);
       __end += __rlen;
     }
   return (__end - __p);
 };
 __lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
 return __lstr;
      }

      _Spec<_CharT> _M_spec{};
    };

}



  template<__format::__char _CharT>
    struct formatter<_CharT, _CharT>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 return _M_f.template _M_parse<_CharT>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_f._M_spec._M_type == __format::_Pres_none
       || _M_f._M_spec._M_type == __format::_Pres_c)
     return _M_f._M_format_character(__u, __fc);
   else if (_M_f._M_spec._M_type == __format::_Pres_esc)
     return _M_f._M_format_character_escaped(__u, __fc);
   else
     return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
 }







    private:
      __format::__formatter_int<_CharT> _M_f;
    };



  template<>
    struct formatter<char, wchar_t>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      {
 return _M_f._M_parse<char>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
 {
   if (_M_f._M_spec._M_type == __format::_Pres_none
       || _M_f._M_spec._M_type == __format::_Pres_c)
     return _M_f._M_format_character(__u, __fc);
   else if (_M_f._M_spec._M_type == __format::_Pres_esc)
     return _M_f._M_format_character_escaped(__u, __fc);
   else
     return _M_f.format(static_cast<unsigned char>(__u), __fc);
 }







    private:
      __format::__formatter_int<wchar_t> _M_f;
    };





  template<__format::__char _CharT>
    struct formatter<_CharT*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 [[__gnu__::__nonnull__]]
 typename basic_format_context<_Out, _CharT>::iterator
 format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<const _CharT*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 [[__gnu__::__nonnull__]]
 typename basic_format_context<_Out, _CharT>::iterator
 format(const _CharT* __u,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<__format::__char _CharT, size_t _Nm>
    struct formatter<_CharT[_Nm], _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const _CharT (&__u)[_Nm],
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format({__u, _Nm}, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<typename _Traits, typename _Alloc>
    struct formatter<basic_string<char, _Traits, _Alloc>, char>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<char>::iterator
      parse(basic_format_parse_context<char>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, char>::iterator
 format(const basic_string<char, _Traits, _Alloc>& __u,
        basic_format_context<_Out, char>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<char> _M_f;
    };


  template<typename _Traits, typename _Alloc>
    struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
        basic_format_context<_Out, wchar_t>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<wchar_t> _M_f;
    };


  template<typename _Traits>
    struct formatter<basic_string_view<char, _Traits>, char>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<char>::iterator
      parse(basic_format_parse_context<char>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, char>::iterator
 format(basic_string_view<char, _Traits> __u,
        basic_format_context<_Out, char>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<char> _M_f;
    };


  template<typename _Traits>
    struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(basic_string_view<wchar_t, _Traits> __u,
        basic_format_context<_Out, wchar_t>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<wchar_t> _M_f;
    };




namespace __format
{


  template<typename _Tp>
    constexpr bool __is_formattable_integer = __is_integer<_Tp>::__value;


  template<> inline constexpr bool __is_formattable_integer<__int128> = true;
  template<> inline constexpr bool __is_formattable_integer<unsigned __int128>
      = true;


  template<> inline constexpr bool __is_formattable_integer<char> = false;
  template<> inline constexpr bool __is_formattable_integer<wchar_t> = false;

  template<> inline constexpr bool __is_formattable_integer<char8_t> = false;

  template<> inline constexpr bool __is_formattable_integer<char16_t> = false;
  template<> inline constexpr bool __is_formattable_integer<char32_t> = false;
}



  template<typename _Tp, __format::__char _CharT>
    requires __format::__is_formattable_integer<_Tp>
    struct formatter<_Tp, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 return _M_f.template _M_parse<_Tp>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }

    private:
      __format::__formatter_int<_CharT> _M_f;
    };



  template<__format::__formattable_float _Tp, __format::__char _CharT>
    struct formatter<_Tp, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }

    private:
      __format::__formatter_fp<_CharT> _M_f;
    };
# 2854 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<__format::__char _CharT>
    struct formatter<const void*, _CharT>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 __format::_Spec<_CharT> __spec{};
 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;




 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;


 __first = __spec._M_parse_width(__first, __last, __pc);

 if (__first != __last)
   {
     if (*__first == 'p')
       ++__first;

     else if (*__first == 'P')
     {
       __spec._M_type = __format::_Pres_P;
       ++__first;
     }

   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
 {
   auto __u = reinterpret_cast<long unsigned int>(__v);
   char __buf[2 + sizeof(__v) * 2];
   auto [__ptr, __ec] = std::to_chars(__buf + 2, std::end(__buf),
          __u, 16);
   int __n = __ptr - __buf;
   __buf[0] = '0';
   __buf[1] = 'x';

   if (_M_spec._M_type == __format::_Pres_P)
     {
       __buf[1] = 'X';
       for (auto __p = __buf + 2; __p != __ptr; ++__p)



  *__p = std::toupper(*__p);

     }


   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<_CharT, char>)
     __str = string_view(__buf, __n);

   else
     {
       auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
       std::__to_wstring_numeric(__buf, __n, __p);
       __str = wstring_view(__p, __n);
     }



   if (_M_spec._M_zero_fill)
     {
       size_t __width = _M_spec._M_get_width(__fc);
       if (__width <= __str.size())
  return __format::__write(__fc.out(), __str);

       auto __out = __fc.out();

       __out = __format::__write(std::move(__out), __str.substr(0, 2));
       __str.remove_prefix(2);
       size_t __nfill = __width - __n;
       return __format::__write_padded(std::move(__out), __str,
           __format::_Align_right,
           __nfill, _CharT('0'));
     }


   return __format::__write_padded_as_spec(__str, __n, __fc, _M_spec,
        __format::_Align_right);
 }

    private:
      __format::_Spec<_CharT> _M_spec{};
    };

  template<__format::__char _CharT>
    struct formatter<void*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__v, __fc); }

    private:
      formatter<const void*, _CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<nullptr_t, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(nullptr, __fc); }

    private:
      formatter<const void*, _CharT> _M_f;
    };
# 3046 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<typename _Out>
    struct format_to_n_result
    {
      _Out out;
      iter_difference_t<_Out> size;
    };


template<typename, typename> class vector;



namespace __format
{
  template<typename _CharT>
    class _Sink_iter
    {
      _Sink<_CharT>* _M_sink = nullptr;

    public:
      using iterator_category = output_iterator_tag;
      using value_type = void;
      using difference_type = ptrdiff_t;
      using pointer = void;
      using reference = void;

      _Sink_iter() = default;
      _Sink_iter(const _Sink_iter&) = default;
      _Sink_iter& operator=(const _Sink_iter&) = default;

      [[__gnu__::__always_inline__]]
      explicit constexpr
      _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator=(_CharT __c)
      {
 _M_sink->_M_write(__c);
 return *this;
      }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator=(basic_string_view<_CharT> __s)
      {
 _M_sink->_M_write(__s);
 return *this;
      }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator*() { return *this; }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator++() { return *this; }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter
      operator++(int) { return *this; }

      auto
      _M_reserve(size_t __n) const
      { return _M_sink->_M_reserve(__n); }
    };




  template<typename _CharT>
    class _Sink
    {
      friend class _Sink_iter<_CharT>;

      span<_CharT> _M_span;
      typename span<_CharT>::iterator _M_next;





      virtual void _M_overflow() = 0;

    protected:

      [[__gnu__::__always_inline__]]
      explicit constexpr
      _Sink(span<_CharT> __span) noexcept
      : _M_span(__span), _M_next(__span.begin())
      { }


      [[__gnu__::__always_inline__]]
      span<_CharT>
      _M_used() const noexcept
      { return _M_span.first(_M_next - _M_span.begin()); }


      [[__gnu__::__always_inline__]]
      constexpr span<_CharT>
      _M_unused() const noexcept
      { return _M_span.subspan(_M_next - _M_span.begin()); }


      [[__gnu__::__always_inline__]]
      constexpr void
      _M_rewind() noexcept
      { _M_next = _M_span.begin(); }


      void
      _M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
      {
 _M_span = __s;
 _M_next = __s.begin() + __pos;
      }


      constexpr void
      _M_write(_CharT __c)
      {
 *_M_next++ = __c;
 if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
   _M_overflow();
      }

      constexpr void
      _M_write(basic_string_view<_CharT> __s)
      {
 span __to = _M_unused();
 while (__to.size() <= __s.size())
   {
     __s.copy(__to.data(), __to.size());
     _M_next += __to.size();
     __s.remove_prefix(__to.size());
     _M_overflow();
     __to = _M_unused();
   }
 if (__s.size())
   {
     __s.copy(__to.data(), __s.size());
     _M_next += __s.size();
   }
      }



      struct _Reservation
      {

 explicit operator bool() const noexcept { return _M_sink; }

 _CharT* get() const noexcept { return _M_sink->_M_next.operator->(); }

 void _M_bump(size_t __n) { _M_sink->_M_bump(__n); }
 _Sink* _M_sink;
      };





      virtual _Reservation
      _M_reserve(size_t __n)
      {
 if (__n <= _M_unused().size())
   return { this };

 if (__n <= _M_span.size())
   {
     _M_overflow();
     if (__n <= _M_unused().size())
       return { this };
   }
 return { nullptr };
      }



      virtual void
      _M_bump(size_t __n)
      { _M_next += __n; }

    public:
      _Sink(const _Sink&) = delete;
      _Sink& operator=(const _Sink&) = delete;

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter<_CharT>
      out() noexcept
      { return _Sink_iter<_CharT>(*this); }
    };


  template<typename _CharT>
    class _Fixedbuf_sink final : public _Sink<_CharT>
    {
      void
      _M_overflow() override
      {
 do { if (std::__is_constant_evaluated() && !bool(false)) std::__glibcxx_assert_fail(); } while (false);
 this->_M_rewind();
      }

    public:
      [[__gnu__::__always_inline__]]
      constexpr explicit
      _Fixedbuf_sink(span<_CharT> __buf)
 : _Sink<_CharT>(__buf)
      { }

      constexpr basic_string_view<_CharT>
      view() const
      {
 auto __s = this->_M_used();
 return basic_string_view<_CharT>(__s.data(), __s.size());
      }
    };


  template<typename _CharT>
    class _Buf_sink : public _Sink<_CharT>
    {
    protected:
      _CharT _M_buf[__stackbuf_size<_CharT>];

      [[__gnu__::__always_inline__]]
      constexpr
      _Buf_sink() noexcept
      : _Sink<_CharT>(_M_buf)
      { }
    };

  using std::vector;



  template<typename _Seq>
    class _Seq_sink final : public _Buf_sink<typename _Seq::value_type>
    {
      using _CharT = typename _Seq::value_type;

      _Seq _M_seq;


      void
      _M_overflow() override
      {
 auto __s = this->_M_used();
 if (__s.empty()) [[unlikely]]
   return;


                                                   ;

 if constexpr (__is_specialization_of<_Seq, basic_string>)
   _M_seq.append(__s.data(), __s.size());
 else
   _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());


 this->_M_rewind();
      }

      typename _Sink<_CharT>::_Reservation
      _M_reserve(size_t __n) override
      {







 if constexpr (__is_specialization_of<_Seq, basic_string>
   || __is_specialization_of<_Seq, vector>)
   {

     if (this->_M_used().size()) [[unlikely]]
       _Seq_sink::_M_overflow();


     const auto __sz = _M_seq.size();
     if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
       _M_seq.__resize_and_overwrite(__sz + __n,
         [](auto, auto __n2) {
           return __n2;
         });
     else
       _M_seq.resize(__sz + __n);



     this->_M_reset(_M_seq, __sz);
     return { this };
   }
 else
   return _Sink<_CharT>::_M_reserve(__n);
      }

      void
      _M_bump(size_t __n) override
      {
 if constexpr (__is_specialization_of<_Seq, basic_string>
   || __is_specialization_of<_Seq, vector>)
   {
     auto __s = this->_M_used();
                                                       ;

     _M_seq.resize(__s.size() + __n);

     this->_M_reset(this->_M_buf);
   }
      }

    public:



      [[__gnu__::__always_inline__]]
      _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
      { }

      _Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)
      : _M_seq(std::move(__s))
      { }

      using _Sink<_CharT>::out;

      _Seq
      get() &&
      {
 if (this->_M_used().size() != 0)
   _Seq_sink::_M_overflow();
 return std::move(_M_seq);
      }



      span<_CharT>
      view()
      {
 auto __s = this->_M_used();
 if (_M_seq.size())
   {
     if (__s.size() != 0)
       _Seq_sink::_M_overflow();
     return _M_seq;
   }
 return __s;
      }
    };




  template<typename _CharT, typename _OutIter>
    class _Iter_sink : public _Buf_sink<_CharT>
    {
      _OutIter _M_out;
      iter_difference_t<_OutIter> _M_max;

    protected:
      size_t _M_count = 0;

      void
      _M_overflow() override
      {
 auto __s = this->_M_used();
 if (_M_max < 0)
   _M_out = ranges::copy(__s, std::move(_M_out)).out;
 else if (_M_count < static_cast<size_t>(_M_max))
   {
     auto __max = _M_max - _M_count;
     span<_CharT> __first;
     if (__max < __s.size())
       __first = __s.first(static_cast<size_t>(__max));
     else
       __first = __s;
     _M_out = ranges::copy(__first, std::move(_M_out)).out;
   }
 this->_M_rewind();
 _M_count += __s.size();
      }

    public:
      [[__gnu__::__always_inline__]]
      explicit
      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
      : _M_out(std::move(__out)), _M_max(__max)
      { }

      using _Sink<_CharT>::out;

      format_to_n_result<_OutIter>
      _M_finish() &&
      {
 if (this->_M_used().size() != 0)
   _Iter_sink::_M_overflow();
 iter_difference_t<_OutIter> __count(_M_count);
 return { std::move(_M_out), __count };
      }
    };
# 3458 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<typename _CharT, contiguous_iterator _OutIter>
    requires same_as<iter_value_t<_OutIter>, _CharT>
    class _Iter_sink<_CharT, _OutIter> : public _Sink<_CharT>
    {
      _OutIter _M_first;
      iter_difference_t<_OutIter> _M_max = -1;
    protected:
      size_t _M_count = 0;
    private:
      _CharT _M_buf[64];

    protected:
      void
      _M_overflow() override
      {
 if (this->_M_unused().size() != 0)
   return;

 auto __s = this->_M_used();

 if (_M_max >= 0)
   {
     _M_count += __s.size();



     this->_M_reset(this->_M_buf);
   }
 else
   {


     this->_M_reset({__s.data(), __s.size() + 1024}, __s.size());
   }
      }

      typename _Sink<_CharT>::_Reservation
      _M_reserve(size_t __n) final
      {
 auto __avail = this->_M_unused();
 if (__n > __avail.size())
   {
     if (_M_max >= 0)
       return {};

     auto __s = this->_M_used();
     this->_M_reset({__s.data(), __s.size() + __n}, __s.size());
   }
 return { this };
      }

    private:
      static span<_CharT>
      _S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
     span<_CharT> __buf) noexcept
      {
 if (__n == 0)
   return __buf;

 if (__n > 0)
   {
     if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
       || sizeof(__n) > sizeof(size_t))
       {

  auto __m = iter_difference_t<_OutIter>((size_t)-1);
  if (__n > __m)
    __n = __m;
       }
     return {__ptr, (size_t)__n};
   }


 if (size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
   return {__ptr, __bytes / sizeof(_CharT)};


 const auto __off = reinterpret_cast<long unsigned int>(__ptr) % 1024;
 __n = (1024 - __off) / sizeof(_CharT);
 if (__n > 0) [[likely]]
   return {__ptr, static_cast<size_t>(__n)};
 else
   return {__ptr, 1};
      }

    public:
      explicit
      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
      : _Sink<_CharT>(_S_make_span(std::to_address(__out), __n, _M_buf)),
 _M_first(__out), _M_max(__n)
      { }

      format_to_n_result<_OutIter>
      _M_finish() &&
      {
 auto __s = this->_M_used();
 if (__s.data() == _M_buf)
   {

     iter_difference_t<_OutIter> __count(_M_count + __s.size());
     return { _M_first + _M_max, __count };
   }
 else
   {
     iter_difference_t<_OutIter> __count(__s.size());
     return { _M_first + __count, __count };
   }
      }
    };

  enum _Arg_t : unsigned char {
    _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
    _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
    _Arg_i128, _Arg_u128,
    _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64,





    _Arg_f128,

    _Arg_max_
  };

  template<typename _Context>
    struct _Arg_value
    {
      using _CharT = typename _Context::char_type;

      struct _HandleBase
      {
 const void* _M_ptr;
 void (*_M_func)();
      };

      union
      {
 monostate _M_none;
 bool _M_bool;
 _CharT _M_c;
 int _M_i;
 unsigned _M_u;
 long long _M_ll;
 unsigned long long _M_ull;
 float _M_flt;
 double _M_dbl;

 long double _M_ldbl;

 const _CharT* _M_str;
 basic_string_view<_CharT> _M_sv;
 const void* _M_ptr;
 _HandleBase _M_handle;

 __int128 _M_i128;
 unsigned __int128 _M_u128;







      };

      [[__gnu__::__always_inline__]]
      _Arg_value() : _M_none() { }







      template<typename _Tp, typename _Self>
 [[__gnu__::__always_inline__]]
 static auto&
 _S_get(_Self& __u) noexcept
 {
   if constexpr (is_same_v<_Tp, bool>)
     return __u._M_bool;
   else if constexpr (is_same_v<_Tp, _CharT>)
     return __u._M_c;
   else if constexpr (is_same_v<_Tp, int>)
     return __u._M_i;
   else if constexpr (is_same_v<_Tp, unsigned>)
     return __u._M_u;
   else if constexpr (is_same_v<_Tp, long long>)
     return __u._M_ll;
   else if constexpr (is_same_v<_Tp, unsigned long long>)
     return __u._M_ull;
   else if constexpr (is_same_v<_Tp, float>)
     return __u._M_flt;
   else if constexpr (is_same_v<_Tp, double>)
     return __u._M_dbl;

   else if constexpr (is_same_v<_Tp, long double>)
     return __u._M_ldbl;






   else if constexpr (is_same_v<_Tp, const _CharT*>)
     return __u._M_str;
   else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
     return __u._M_sv;
   else if constexpr (is_same_v<_Tp, const void*>)
     return __u._M_ptr;

   else if constexpr (is_same_v<_Tp, __int128>)
     return __u._M_i128;
   else if constexpr (is_same_v<_Tp, unsigned __int128>)
     return __u._M_u128;





   else if constexpr (derived_from<_Tp, _HandleBase>)
     return static_cast<_Tp&>(__u._M_handle);

 }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 auto&
 _M_get() noexcept
 { return _S_get<_Tp>(*this); }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 const auto&
 _M_get() const noexcept
 { return _S_get<_Tp>(*this); }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 void
 _M_set(_Tp __v) noexcept
 {
   if constexpr (derived_from<_Tp, _HandleBase>)
     std::construct_at(&_M_handle, __v);
   else
     _S_get<_Tp>(*this) = __v;
 }
      };


  template<typename _Context, typename... _Args>
    class _Arg_store;

  template<typename _Visitor, typename _Ctx>
    decltype(auto) __visit_format_arg(_Visitor&&, basic_format_arg<_Ctx>);

  template<typename _Ch, typename _Tp>
    consteval _Arg_t
    __to_arg_t_enum() noexcept;
}


  template<typename _Context>
    class basic_format_arg
    {
      using _CharT = typename _Context::char_type;

      template<typename _Tp>
 static constexpr bool __formattable
   = __format::__formattable_with<_Tp, _Context>;

    public:
      class handle : public __format::_Arg_value<_Context>::_HandleBase
      {
 using _Base = typename __format::_Arg_value<_Context>::_HandleBase;


 template<typename _Tp>
   using __maybe_const_t
     = __conditional_t<__formattable<const _Tp>, const _Tp, _Tp>;

 template<typename _Tq>
   static void
   _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
      _Context& __format_ctx, const void* __ptr)
   {
     using _Td = remove_const_t<_Tq>;
     typename _Context::template formatter_type<_Td> __f;
     __parse_ctx.advance_to(__f.parse(__parse_ctx));
     _Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
     __format_ctx.advance_to(__f.format(__val, __format_ctx));
   }

 template<typename _Tp>
   explicit
   handle(_Tp& __val) noexcept
   {
     this->_M_ptr = __builtin_addressof(__val);
     auto __func = _S_format<__maybe_const_t<_Tp>>;
     this->_M_func = reinterpret_cast<void(*)()>(__func);
   }

 friend class basic_format_arg<_Context>;

      public:
 handle(const handle&) = default;
 handle& operator=(const handle&) = default;

 [[__gnu__::__always_inline__]]
 void
 format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
 {
   using _Func = void(*)(basic_format_parse_context<_CharT>&,
    _Context&, const void*);
   auto __f = reinterpret_cast<_Func>(this->_M_func);
   __f(__pc, __fc, this->_M_ptr);
 }
      };

      [[__gnu__::__always_inline__]]
      basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }

      [[nodiscard,__gnu__::__always_inline__]]
      explicit operator bool() const noexcept
      { return _M_type != __format::_Arg_none; }
# 3797 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
    private:
      template<typename _Ctx>
 friend class basic_format_args;

      template<typename _Ctx, typename... _Args>
 friend class __format::_Arg_store;

      static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);

      __format::_Arg_value<_Context> _M_val;
      __format::_Arg_t _M_type;




      template<typename _Tp>
 static consteval auto
 _S_to_arg_type()
 {
   using _Td = remove_const_t<_Tp>;
   if constexpr (is_same_v<_Td, bool>)
     return type_identity<bool>();
   else if constexpr (is_same_v<_Td, _CharT>)
     return type_identity<_CharT>();
   else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
     return type_identity<_CharT>();

   else if constexpr (is_same_v<_Td, __int128>)
     return type_identity<__int128>();
   else if constexpr (is_same_v<_Td, unsigned __int128>)
     return type_identity<unsigned __int128>();

   else if constexpr (__is_signed_integer<_Td>::value)
     {
       if constexpr (sizeof(_Td) <= sizeof(int))
  return type_identity<int>();
       else if constexpr (sizeof(_Td) <= sizeof(long long))
  return type_identity<long long>();
     }
   else if constexpr (__is_unsigned_integer<_Td>::value)
     {
       if constexpr (sizeof(_Td) <= sizeof(unsigned))
  return type_identity<unsigned>();
       else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
  return type_identity<unsigned long long>();
     }
   else if constexpr (is_same_v<_Td, float>)
     return type_identity<float>();
   else if constexpr (is_same_v<_Td, double>)
     return type_identity<double>();

   else if constexpr (is_same_v<_Td, long double>)
     return type_identity<long double>();
# 3858 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
   else if constexpr (is_same_v<_Td, _Float16>)
     return type_identity<float>();
# 3887 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
   else if constexpr (__is_specialization_of<_Td, basic_string_view>
       || __is_specialization_of<_Td, basic_string>)
     {
       if constexpr (is_same_v<typename _Td::value_type, _CharT>)
  return type_identity<basic_string_view<_CharT>>();
       else
  return type_identity<handle>();
     }
   else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
     return type_identity<const _CharT*>();
   else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
     return type_identity<const _CharT*>();
   else if constexpr (is_void_v<remove_pointer_t<_Td>>)
     return type_identity<const void*>();
   else if constexpr (is_same_v<_Td, nullptr_t>)
     return type_identity<const void*>();
   else
     return type_identity<handle>();
 }


      template<typename _Tp>
 using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;


      template<typename _Tp>
 static consteval __format::_Arg_t
 _S_to_enum()
 {
   using namespace __format;
   if constexpr (is_same_v<_Tp, bool>)
     return _Arg_bool;
   else if constexpr (is_same_v<_Tp, _CharT>)
     return _Arg_c;
   else if constexpr (is_same_v<_Tp, int>)
     return _Arg_i;
   else if constexpr (is_same_v<_Tp, unsigned>)
     return _Arg_u;
   else if constexpr (is_same_v<_Tp, long long>)
     return _Arg_ll;
   else if constexpr (is_same_v<_Tp, unsigned long long>)
     return _Arg_ull;
   else if constexpr (is_same_v<_Tp, float>)
     return _Arg_flt;
   else if constexpr (is_same_v<_Tp, double>)
     return _Arg_dbl;

   else if constexpr (is_same_v<_Tp, long double>)
     return _Arg_ldbl;







   else if constexpr (is_same_v<_Tp, const _CharT*>)
     return _Arg_str;
   else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
     return _Arg_sv;
   else if constexpr (is_same_v<_Tp, const void*>)
     return _Arg_ptr;

   else if constexpr (is_same_v<_Tp, __int128>)
     return _Arg_i128;
   else if constexpr (is_same_v<_Tp, unsigned __int128>)
     return _Arg_u128;






   else if constexpr (is_same_v<_Tp, handle>)
     return _Arg_handle;
 }

      template<typename _Tp>
 void
 _M_set(_Tp __v) noexcept
 {
   _M_type = _S_to_enum<_Tp>();
   _M_val._M_set(__v);
 }

      template<typename _Tp>
 requires __format::__formattable_with<_Tp, _Context>
 explicit
 basic_format_arg(_Tp& __v) noexcept
 {
   using _Td = _Normalize<_Tp>;
   if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
     _M_set(_Td{__v.data(), __v.size()});
   else if constexpr (is_same_v<remove_const_t<_Tp>, char>
          && is_same_v<_CharT, wchar_t>)
     _M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
   else
     _M_set(static_cast<_Td>(__v));
 }

      template<typename _Ctx, typename... _Argz>
 friend auto
 make_format_args(_Argz&...) noexcept;

      template<typename _Visitor, typename _Ctx>
 friend decltype(auto)
 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);

      template<typename _Visitor, typename _Ctx>
 friend decltype(auto)
 __format::__visit_format_arg(_Visitor&&, basic_format_arg<_Ctx>);

      template<typename _Ch, typename _Tp>
 friend consteval __format::_Arg_t
 __format::__to_arg_t_enum() noexcept;

      template<typename _Visitor>
 decltype(auto)
 _M_visit(_Visitor&& __vis, __format::_Arg_t __type)
 {
   using namespace __format;
   switch (__type)
   {
     case _Arg_none:
       return std::forward<_Visitor>(__vis)(_M_val._M_none);
     case _Arg_bool:
       return std::forward<_Visitor>(__vis)(_M_val._M_bool);
     case _Arg_c:
       return std::forward<_Visitor>(__vis)(_M_val._M_c);
     case _Arg_i:
       return std::forward<_Visitor>(__vis)(_M_val._M_i);
     case _Arg_u:
       return std::forward<_Visitor>(__vis)(_M_val._M_u);
     case _Arg_ll:
       return std::forward<_Visitor>(__vis)(_M_val._M_ll);
     case _Arg_ull:
       return std::forward<_Visitor>(__vis)(_M_val._M_ull);

     case _Arg_flt:
       return std::forward<_Visitor>(__vis)(_M_val._M_flt);
     case _Arg_dbl:
       return std::forward<_Visitor>(__vis)(_M_val._M_dbl);

     case _Arg_ldbl:
       return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);







     case _Arg_str:
       return std::forward<_Visitor>(__vis)(_M_val._M_str);
     case _Arg_sv:
       return std::forward<_Visitor>(__vis)(_M_val._M_sv);
     case _Arg_ptr:
       return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
     case _Arg_handle:
     {
       auto& __h = static_cast<handle&>(_M_val._M_handle);
       return std::forward<_Visitor>(__vis)(__h);
     }

     case _Arg_i128:
       return std::forward<_Visitor>(__vis)(_M_val._M_i128);
     case _Arg_u128:
       return std::forward<_Visitor>(__vis)(_M_val._M_u128);







     default:

       __builtin_unreachable();
   }
 }

      template<typename _Visitor>
 decltype(auto)
 _M_visit_user(_Visitor&& __vis, __format::_Arg_t __type)
 {
   return _M_visit([&__vis]<typename _Tp>(_Tp& __val) -> decltype(auto)
     {
       constexpr bool __user_facing = __is_one_of<_Tp,
  monostate, bool, _CharT,
  int, unsigned int, long long int, unsigned long long int,
  float, double, long double,
  const _CharT*, basic_string_view<_CharT>,
  const void*, handle>::value;
      if constexpr (__user_facing)
        return std::forward<_Visitor>(__vis)(__val);
      else
        {
   handle __h(__val);
   return std::forward<_Visitor>(__vis)(__h);
        }
    }, __type);
 }
    };

  template<typename _Visitor, typename _Context>

    inline decltype(auto)
    visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
    {
      return __arg._M_visit_user(std::forward<_Visitor>(__vis), __arg._M_type);
    }


namespace __format
{
  template<typename _Visitor, typename _Ctx>
    inline decltype(auto)
    __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx> __arg)
    {
      return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
    }

  struct _WidthPrecVisitor
  {
    template<typename _Tp>
      size_t
      operator()(_Tp& __arg) const
      {
 if constexpr (is_same_v<_Tp, monostate>)
   __format::__invalid_arg_id_in_format_string();



 else if constexpr (sizeof(_Tp) <= sizeof(long long))
   {


     if constexpr (__is_unsigned_integer<_Tp>::value)
       return __arg;
     else if constexpr (__is_signed_integer<_Tp>::value)
       if (__arg >= 0)
  return __arg;
   }
 __throw_format_error("format error: argument used for width or "
        "precision must be a non-negative integer");
      }
  };

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename _Context>
    inline size_t
    __int_from_arg(const basic_format_arg<_Context>& __arg)
    { return __format::__visit_format_arg(_WidthPrecVisitor(), __arg); }


  template<int _Bits, size_t _Nm>
    constexpr auto
    __pack_arg_types(const array<_Arg_t, _Nm>& __types)
    {
      long unsigned int __packed_types = 0;
      for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
 __packed_types = (__packed_types << _Bits) | *__i;
      return __packed_types;
    }
}


  template<typename _Context>
    class basic_format_args
    {
      static constexpr int _S_packed_type_bits = 5;
      static constexpr int _S_packed_type_mask = 0b11111;
      static constexpr int _S_max_packed_args = 12;

      static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );

      template<typename... _Args>
 using _Store = __format::_Arg_store<_Context, _Args...>;

      template<typename _Ctx, typename... _Args>
 friend class __format::_Arg_store;

      using uint64_t = long unsigned int;
      using _Format_arg = basic_format_arg<_Context>;
      using _Format_arg_val = __format::_Arg_value<_Context>;





      uint64_t _M_packed_size : 4;
      uint64_t _M_unpacked_size : 60;

      union {
 const _Format_arg_val* _M_values;
 const _Format_arg* _M_args;
      };

      size_t
      _M_size() const noexcept
      { return _M_packed_size ? _M_packed_size : _M_unpacked_size; }

      typename __format::_Arg_t
      _M_type(size_t __i) const noexcept
      {
 uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
 return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
      }

      template<typename _Ctx, typename... _Args>
 friend auto
 make_format_args(_Args&...) noexcept;


      template<typename... _Args>
 static consteval array<__format::_Arg_t, sizeof...(_Args)>
 _S_types_to_pack()
 { return {_Format_arg::template _S_to_enum<_Args>()...}; }

    public:
      template<typename... _Args>
 basic_format_args(const _Store<_Args...>& __store) noexcept;

      [[nodiscard,__gnu__::__always_inline__]]
      basic_format_arg<_Context>
      get(size_t __i) const noexcept
      {
 basic_format_arg<_Context> __arg;
 if (__i < _M_packed_size)
   {
     __arg._M_type = _M_type(__i);
     __arg._M_val = _M_values[__i];
   }
 else if (_M_packed_size == 0 && __i < _M_unpacked_size)
   __arg = _M_args[__i];
 return __arg;
      }
    };



  template<typename _Context, typename... _Args>
    basic_format_args(__format::_Arg_store<_Context, _Args...>)
      -> basic_format_args<_Context>;

  template<typename _Context, typename... _Args>
    auto
    make_format_args(_Args&... __fmt_args) noexcept;


  template<typename _Context, typename... _Args>
    class __format::_Arg_store
    {
      friend std::basic_format_args<_Context>;

      template<typename _Ctx, typename... _Argz>
 friend auto std::



 make_format_args(_Argz&...) noexcept;



      static constexpr bool _S_values_only
 = sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;

      using _Element_t
 = __conditional_t<_S_values_only,
     __format::_Arg_value<_Context>,
     basic_format_arg<_Context>>;

      _Element_t _M_args[sizeof...(_Args)];

      template<typename _Tp>
 static _Element_t
 _S_make_elt(_Tp& __v)
 {
   using _Tq = remove_const_t<_Tp>;
   using _CharT = typename _Context::char_type;
   static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
   "std::formatter must be specialized for the type "
   "of each format arg");
   using __format::__formattable_with;
   if constexpr (is_const_v<_Tp>)
     if constexpr (!__formattable_with<_Tp, _Context>)
       if constexpr (__formattable_with<_Tq, _Context>)
  static_assert(__formattable_with<_Tp, _Context>,
         "format arg must be non-const because its "
         "std::formatter specialization has a "
         "non-const reference parameter");
   basic_format_arg<_Context> __arg(__v);
   if constexpr (_S_values_only)
     return __arg._M_val;
   else
     return __arg;
 }

      template<typename... _Tp>
 requires (sizeof...(_Tp) == sizeof...(_Args))
 [[__gnu__::__always_inline__]]
 _Arg_store(_Tp&... __a) noexcept
 : _M_args{_S_make_elt(__a)...}
 { }
    };

  template<typename _Context>
    class __format::_Arg_store<_Context>
    { };

  template<typename _Context>
    template<typename... _Args>
      inline
      basic_format_args<_Context>::
      basic_format_args(const _Store<_Args...>& __store) noexcept
      {
 if constexpr (sizeof...(_Args) == 0)
   {
     _M_packed_size = 0;
     _M_unpacked_size = 0;
     _M_args = nullptr;
   }
 else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
   {

     _M_packed_size = sizeof...(_Args);

     _M_unpacked_size
       = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());

     _M_values = __store._M_args;
   }
 else
   {

     _M_packed_size = 0;

     _M_unpacked_size = sizeof...(_Args);

     _M_args = __store._M_args;
   }
      }


  template<typename _Context = format_context, typename... _Args>
    [[nodiscard,__gnu__::__always_inline__]]
    inline auto
    make_format_args(_Args&... __fmt_args) noexcept
    {
      using _Fmt_arg = basic_format_arg<_Context>;
      using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
       _Normalize<_Args>...>;
      return _Store(__fmt_args...);
    }



  template<typename... _Args>
    [[nodiscard,__gnu__::__always_inline__]]
    inline auto
    make_wformat_args(_Args&... __args) noexcept
    { return std::make_format_args<wformat_context>(__args...); }



namespace __format
{
  template<typename _Out, typename _CharT, typename _Context>
    _Out
    __do_vformat_to(_Out, basic_string_view<_CharT>,
      const basic_format_args<_Context>&,
      const locale* = nullptr);

  template<typename _CharT> struct __formatter_chrono;

}
# 4379 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<typename _Out, typename _CharT>
    class basic_format_context
    {
      static_assert( output_iterator<_Out, const _CharT&> );

      basic_format_args<basic_format_context> _M_args;
      _Out _M_out;
      __format::_Optional_locale _M_loc;

      basic_format_context(basic_format_args<basic_format_context> __args,
      _Out __out)
      : _M_args(__args), _M_out(std::move(__out))
      { }

      basic_format_context(basic_format_args<basic_format_context> __args,
      _Out __out, const std::locale& __loc)
      : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
      { }




      basic_format_context(const basic_format_context&) = delete;
      basic_format_context& operator=(const basic_format_context&) = delete;

      template<typename _Out2, typename _CharT2, typename _Context2>
 friend _Out2
 __format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
      const basic_format_args<_Context2>&,
      const locale*);

      friend __format::__formatter_chrono<_CharT>;

    public:
      ~basic_format_context() = default;

      using iterator = _Out;
      using char_type = _CharT;
      template<typename _Tp>
 using formatter_type = formatter<_Tp, _CharT>;

      [[nodiscard]]
      basic_format_arg<basic_format_context>
      arg(size_t __id) const noexcept
      { return _M_args.get(__id); }

      [[nodiscard]]
      std::locale locale() { return _M_loc.value(); }

      [[nodiscard]]
      iterator out() { return std::move(_M_out); }

      void advance_to(iterator __it) { _M_out = std::move(__it); }
    };



namespace __format
{





  template<typename _CharT>
    struct _Scanner
    {
      using iterator = typename basic_format_parse_context<_CharT>::iterator;

      struct _Parse_context : basic_format_parse_context<_CharT>
      {
 using basic_format_parse_context<_CharT>::basic_format_parse_context;
 const _Arg_t* _M_types = nullptr;
      } _M_pc;

      constexpr explicit
      _Scanner(basic_string_view<_CharT> __str, size_t __nargs = (size_t)-1)
      : _M_pc(__str, __nargs)
      { }

      constexpr iterator begin() const noexcept { return _M_pc.begin(); }
      constexpr iterator end() const noexcept { return _M_pc.end(); }

      constexpr void
      _M_scan()
      {
 basic_string_view<_CharT> __fmt = _M_fmt_str();

 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
   {
     _M_pc.advance_to(begin() + 1);
     _M_format_arg(_M_pc.next_arg_id());
     return;
   }

 size_t __lbr = __fmt.find('{');
 size_t __rbr = __fmt.find('}');

 while (__fmt.size())
   {
     auto __cmp = __lbr <=> __rbr;
     if (__cmp == 0)
       {
  _M_on_chars(end());
  _M_pc.advance_to(end());
  return;
       }
     else if (__cmp < 0)
       {
  if (__lbr + 1 == __fmt.size()
        || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
    __format::__unmatched_left_brace_in_format_string();
  const bool __is_escape = __fmt[__lbr + 1] == '{';
  iterator __last = begin() + __lbr + int(__is_escape);
  _M_on_chars(__last);
  _M_pc.advance_to(__last + 1);
  __fmt = _M_fmt_str();
  if (__is_escape)
    {
      if (__rbr != __fmt.npos)
        __rbr -= __lbr + 2;
      __lbr = __fmt.find('{');
    }
  else
    {
      _M_on_replacement_field();
      __fmt = _M_fmt_str();
      __lbr = __fmt.find('{');
      __rbr = __fmt.find('}');
    }
       }
     else
       {
  if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
    __format::__unmatched_right_brace_in_format_string();
  iterator __last = begin() + __rbr;
  _M_on_chars(__last);
  _M_pc.advance_to(__last + 1);
  __fmt = _M_fmt_str();
  if (__lbr != __fmt.npos)
    __lbr -= __rbr + 1;
  __rbr = __fmt.find('}');
       }
   }
      }

      constexpr basic_string_view<_CharT>
      _M_fmt_str() const noexcept
      { return {begin(), end()}; }

      constexpr virtual void _M_on_chars(iterator) { }

      constexpr void _M_on_replacement_field()
      {
 auto __next = begin();

 size_t __id;
 if (*__next == '}')
   __id = _M_pc.next_arg_id();
 else if (*__next == ':')
   {
     __id = _M_pc.next_arg_id();
     _M_pc.advance_to(++__next);
   }
 else
   {
     auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
     if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
       __format::__invalid_arg_id_in_format_string();
     _M_pc.check_arg_id(__id = __i);
     if (*__ptr == ':')
       {
  _M_pc.advance_to(++__ptr);
       }
     else
       _M_pc.advance_to(__ptr);
   }
 _M_format_arg(__id);
 if (begin() == end() || *begin() != '}')
   __format::__unmatched_left_brace_in_format_string();
 _M_pc.advance_to(begin() + 1);
      }

      constexpr virtual void _M_format_arg(size_t __id) = 0;
    };


  template<typename _Out, typename _CharT>
    class _Formatting_scanner : public _Scanner<_CharT>
    {
    public:
      _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
     basic_string_view<_CharT> __str)
      : _Scanner<_CharT>(__str), _M_fc(__fc)
      { }

    private:
      basic_format_context<_Out, _CharT>& _M_fc;

      using iterator = typename _Scanner<_CharT>::iterator;

      constexpr void
      _M_on_chars(iterator __last) override
      {
 basic_string_view<_CharT> __str(this->begin(), __last);
 _M_fc.advance_to(__format::__write(_M_fc.out(), __str));
      }

      constexpr void
      _M_format_arg(size_t __id) override
      {
 using _Context = basic_format_context<_Out, _CharT>;
 using handle = typename basic_format_arg<_Context>::handle;

 __format::__visit_format_arg([this](auto& __arg) {
   using _Type = remove_reference_t<decltype(__arg)>;
   using _Formatter = typename _Context::template formatter_type<_Type>;
   if constexpr (is_same_v<_Type, monostate>)
     __format::__invalid_arg_id_in_format_string();
   else if constexpr (is_same_v<_Type, handle>)
     __arg.format(this->_M_pc, this->_M_fc);
   else if constexpr (is_default_constructible_v<_Formatter>)
     {
       _Formatter __f;
       this->_M_pc.advance_to(__f.parse(this->_M_pc));
       this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
     }
   else
     static_assert(__format::__formattable_with<_Type, _Context>);
 }, _M_fc.arg(__id));
      }
    };

  template<typename _CharT, typename _Tp>
    consteval _Arg_t
    __to_arg_t_enum() noexcept
    {
      using _Context = __format::__format_context<_CharT>;
      using _Fmt_arg = basic_format_arg<_Context>;
      using _NormalizedTp = typename _Fmt_arg::template _Normalize<_Tp>;
      return _Fmt_arg::template _S_to_enum<_NormalizedTp>();
    }


  template<typename _CharT, typename... _Args>
    class _Checking_scanner : public _Scanner<_CharT>
    {
      static_assert(
 (is_default_constructible_v<formatter<_Args, _CharT>> && ...),
 "std::formatter must be specialized for each type being formatted");

    public:
      consteval
      _Checking_scanner(basic_string_view<_CharT> __str)
      : _Scanner<_CharT>(__str, sizeof...(_Args))
      {



      }

    private:
      constexpr void
      _M_format_arg(size_t __id) override
      {
 if constexpr (sizeof...(_Args) != 0)
   {
     if (__id < sizeof...(_Args))
       {
  _M_parse_format_spec<_Args...>(__id);
  return;
       }
   }
 __builtin_unreachable();
      }

      template<typename _Tp, typename... _OtherArgs>
 constexpr void
 _M_parse_format_spec(size_t __id)
 {
   if (__id == 0)
     {
       formatter<_Tp, _CharT> __f;
       this->_M_pc.advance_to(__f.parse(this->_M_pc));
     }
   else if constexpr (sizeof...(_OtherArgs) != 0)
     _M_parse_format_spec<_OtherArgs...>(__id - 1);
   else
     __builtin_unreachable();
 }





    };

  template<typename _Out, typename _CharT, typename _Context>
    inline _Out
    __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
      const basic_format_args<_Context>& __args,
      const locale* __loc)
    {
      _Iter_sink<_CharT, _Out> __sink(std::move(__out));
      _Sink_iter<_CharT> __sink_out;

      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 __sink_out = __out;
      else
 __sink_out = __sink.out();

      if constexpr (is_same_v<_CharT, char>)

 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
   {
     bool __done = false;
     __format::__visit_format_arg([&](auto& __arg) {
       using _Tp = remove_cvref_t<decltype(__arg)>;
       if constexpr (is_same_v<_Tp, bool>)
  {
    size_t __len = 4 + !__arg;
    const char* __chars[] = { "false", "true" };
    if (auto __res = __sink_out._M_reserve(__len))
      {
        __builtin_memcpy(__res.get(), __chars[__arg], __len);
        __res._M_bump(__len);
        __done = true;
      }
  }
       else if constexpr (is_same_v<_Tp, char>)
  {
    if (auto __res = __sink_out._M_reserve(1))
      {
        *__res.get() = __arg;
        __res._M_bump(1);
        __done = true;
      }
  }
       else if constexpr (is_integral_v<_Tp>)
  {
    make_unsigned_t<_Tp> __uval;
    const bool __neg = __arg < 0;
    if (__neg)
      __uval = make_unsigned_t<_Tp>(~__arg) + 1u;
    else
      __uval = __arg;
    const auto __n = __detail::__to_chars_len(__uval);
    if (auto __res = __sink_out._M_reserve(__n + __neg))
      {
        auto __ptr = __res.get();
        *__ptr = '-';
        __detail::__to_chars_10_impl(__ptr + (int)__neg, __n,
         __uval);
        __res._M_bump(__n + __neg);
        __done = true;
      }
  }
       else if constexpr (is_convertible_v<_Tp, string_view>)
  {
    string_view __sv = __arg;
    if (auto __res = __sink_out._M_reserve(__sv.size()))
      {
        __builtin_memcpy(__res.get(), __sv.data(), __sv.size());
        __res._M_bump(__sv.size());
        __done = true;
      }
  }
     }, __args.get(0));

     if (__done)
       {
  if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
    return __sink_out;
  else
    return std::move(__sink)._M_finish().out;
       }
   }

      auto __ctx = __loc == nullptr
       ? _Context(__args, __sink_out)
       : _Context(__args, __sink_out, *__loc);
      _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
      __scanner._M_scan();

      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 return __ctx.out();
      else
 return std::move(__sink)._M_finish().out;
    }
#pragma GCC diagnostic pop

}
# 4800 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
  template<typename _CharT, typename... _Args>
    template<typename _Tp>
      requires convertible_to<const _Tp&, basic_string_view<_CharT>>
      consteval
      basic_format_string<_CharT, _Args...>::
      basic_format_string(const _Tp& __s)
      : _M_str(__s)
      {
 __format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
   __scanner(_M_str);
 __scanner._M_scan();
      }



  template<typename _Out> requires output_iterator<_Out, const char&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, string_view __fmt, format_args __args)
    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }


  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }


  template<typename _Out> requires output_iterator<_Out, const char&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, const locale& __loc, string_view __fmt,
        format_args __args)
    {
      return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
    }


  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
        wformat_args __args)
    {
      return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
    }


  [[nodiscard]]
  inline string
  vformat(string_view __fmt, format_args __args)
  {
    __format::_Str_sink<char> __buf;
    std::vformat_to(__buf.out(), __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline wstring
  vformat(wstring_view __fmt, wformat_args __args)
  {
    __format::_Str_sink<wchar_t> __buf;
    std::vformat_to(__buf.out(), __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline string
  vformat(const locale& __loc, string_view __fmt, format_args __args)
  {
    __format::_Str_sink<char> __buf;
    std::vformat_to(__buf.out(), __loc, __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline wstring
  vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
  {
    __format::_Str_sink<wchar_t> __buf;
    std::vformat_to(__buf.out(), __loc, __fmt, __args);
    return std::move(__buf).get();
  }


  template<typename... _Args>
    [[nodiscard]]
    inline string
    format(format_string<_Args...> __fmt, _Args&&... __args)
    { return std::vformat(__fmt.get(), std::make_format_args(__args...)); }


  template<typename... _Args>
    [[nodiscard]]
    inline wstring
    format(wformat_string<_Args...> __fmt, _Args&&... __args)
    { return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }


  template<typename... _Args>
    [[nodiscard]]
    inline string
    format(const locale& __loc, format_string<_Args...> __fmt,
    _Args&&... __args)
    {
      return std::vformat(__loc, __fmt.get(),
     std::make_format_args(__args...));
    }


  template<typename... _Args>
    [[nodiscard]]
    inline wstring
    format(const locale& __loc, wformat_string<_Args...> __fmt,
    _Args&&... __args)
    {
      return std::vformat(__loc, __fmt.get(),
     std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline _Out
    format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __fmt.get(),
        std::make_format_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline _Out
    format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __fmt.get(),
        std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline _Out
    format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
       _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
        std::make_format_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline _Out
    format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
       _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __fmt.get(),
        std::make_format_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __fmt.get(),
        std::make_wformat_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __loc, __fmt.get(),
        std::make_format_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
      return std::move(__sink)._M_finish();
    }



namespace __format
{

  template<typename _CharT>
    class _Counting_sink final : public _Iter_sink<_CharT, _CharT*>
    {
    public:
      _Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }

      [[__gnu__::__always_inline__]]
      size_t
      count() const
      { return this->_M_count + this->_M_used().size(); }
    };
# 5060 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
}


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Counting_sink<char> __buf;
      std::vformat_to(__buf.out(), __fmt.get(),
        std::make_format_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Counting_sink<wchar_t> __buf;
      std::vformat_to(__buf.out(), __fmt.get(),
        std::make_wformat_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(const locale& __loc, format_string<_Args...> __fmt,
     _Args&&... __args)
    {
      __format::_Counting_sink<char> __buf;
      std::vformat_to(__buf.out(), __loc, __fmt.get(),
        std::make_format_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
     _Args&&... __args)
    {
      __format::_Counting_sink<wchar_t> __buf;
      std::vformat_to(__buf.out(), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
      return __buf.count();
    }
# 5755 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/format" 3
}

#pragma GCC diagnostic pop
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{


namespace chrono
{




namespace __detail
{



  template<typename _Period, typename _CharT>
    constexpr basic_string_view<_CharT>
    __units_suffix() noexcept
    {
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
      if constexpr (is_same_v<_Period, atto>) return ::std::__format::_Widen<_CharT>("as", L"as"); else
      if constexpr (is_same_v<_Period, femto>) return ::std::__format::_Widen<_CharT>("fs", L"fs"); else
      if constexpr (is_same_v<_Period, pico>) return ::std::__format::_Widen<_CharT>("ps", L"ps"); else
      if constexpr (is_same_v<_Period, nano>) return ::std::__format::_Widen<_CharT>("ns", L"ns"); else
      if constexpr (is_same_v<_Period, milli>) return ::std::__format::_Widen<_CharT>("ms", L"ms"); else





      if constexpr (is_same_v<_Period, micro>) return ::std::__format::_Widen<_CharT>("us", L"us"); else

      if constexpr (is_same_v<_Period, centi>) return ::std::__format::_Widen<_CharT>("cs", L"cs"); else
      if constexpr (is_same_v<_Period, deci>) return ::std::__format::_Widen<_CharT>("ds", L"ds"); else
      if constexpr (is_same_v<_Period, ratio<1> >) return ::std::__format::_Widen<_CharT>("s", L"s"); else
      if constexpr (is_same_v<_Period, deca>) return ::std::__format::_Widen<_CharT>("das", L"das"); else
      if constexpr (is_same_v<_Period, hecto>) return ::std::__format::_Widen<_CharT>("hs", L"hs"); else
      if constexpr (is_same_v<_Period, kilo>) return ::std::__format::_Widen<_CharT>("ks", L"ks"); else
      if constexpr (is_same_v<_Period, mega>) return ::std::__format::_Widen<_CharT>("Ms", L"Ms"); else
      if constexpr (is_same_v<_Period, giga>) return ::std::__format::_Widen<_CharT>("Gs", L"Gs"); else
      if constexpr (is_same_v<_Period, tera>) return ::std::__format::_Widen<_CharT>("Ts", L"Ts"); else
      if constexpr (is_same_v<_Period, tera>) return ::std::__format::_Widen<_CharT>("Ts", L"Ts"); else
      if constexpr (is_same_v<_Period, peta>) return ::std::__format::_Widen<_CharT>("Ps", L"Ps"); else
      if constexpr (is_same_v<_Period, exa>) return ::std::__format::_Widen<_CharT>("Es", L"Es"); else
      if constexpr (is_same_v<_Period, ratio<60> >) return ::std::__format::_Widen<_CharT>("min", L"min"); else
      if constexpr (is_same_v<_Period, ratio<3600> >) return ::std::__format::_Widen<_CharT>("h", L"h"); else
      if constexpr (is_same_v<_Period, ratio<86400> >) return ::std::__format::_Widen<_CharT>("d", L"d"); else

 return {};
    }

  template<typename _Period, typename _CharT, typename _Out>
    inline _Out
    __fmt_units_suffix(_Out __out) noexcept
    {
      if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
 return __format::__write(std::move(__out), __s);
      else if constexpr (_Period::den == 1)
 return std::format_to(std::move(__out), ::std::__format::_Widen<_CharT>("[{}]s", L"[{}]s"),
         (uintmax_t)_Period::num);
      else
 return std::format_to(std::move(__out), ::std::__format::_Widen<_CharT>("[{}/{}]s", L"[{}/{}]s"),
         (uintmax_t)_Period::num,
         (uintmax_t)_Period::den);
    }
}






  template<typename _CharT, typename _Traits,
    typename _Rep, typename _Period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const duration<_Rep, _Period>& __d)
    {
      using _Out = ostreambuf_iterator<_CharT, _Traits>;
      using period = typename _Period::type;
      std::basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());


      __s << +__d.count();
      __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
      __os << std::move(__s).str();
      return __os;
    }


namespace __detail
{


  template<typename _Duration>
    struct __local_time_fmt
    {
      local_time<_Duration> _M_time;
      const string* _M_abbrev;
      const seconds* _M_offset_sec;
    };



  template<typename _Duration>
    using __local_time_fmt_for
      = __local_time_fmt<common_type_t<_Duration, seconds>>;
}
# 177 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
  template<typename _Duration>
    inline __detail::__local_time_fmt<_Duration>
    local_time_format(local_time<_Duration> __time,
        const string* __abbrev = nullptr,
        const seconds* __offset_sec = nullptr)
    { return {__time, __abbrev, __offset_sec}; }


}


namespace __format
{
  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __no_timezone_available()
  { __throw_format_error("format error: no timezone available for %Z or %z"); }

  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __not_valid_for_duration()
  { __throw_format_error("format error: chrono-format-spec not valid for "
    "chrono::duration"); }

  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __invalid_chrono_spec()
  { __throw_format_error("format error: chrono-format-spec not valid for "
    "argument type"); }

  template<typename _CharT>
    struct _ChronoSpec : _Spec<_CharT>
    {
      basic_string_view<_CharT> _M_chrono_specs;







      constexpr bool
      _M_locale_specific() const noexcept
      { return this->_M_reserved; }

      constexpr void
      _M_locale_specific(bool __b) noexcept
      { this->_M_reserved = __b; }
    };




  enum _ChronoParts {
    _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
    _TimeZone = 32,
    _Date = _Year | _Month | _Day | _Weekday,
    _DateTime = _Date | _TimeOfDay,
    _ZonedDateTime = _DateTime | _TimeZone,
    _Duration = 128
  };

  constexpr _ChronoParts
  operator|(_ChronoParts __x, _ChronoParts __y) noexcept
  { return static_cast<_ChronoParts>((int)__x | (int)__y); }

  constexpr _ChronoParts&
  operator|=(_ChronoParts& __x, _ChronoParts __y) noexcept
  { return __x = __x | __y; }


  template<typename _CharT>
    struct __formatter_chrono
    {
      using __string_view = basic_string_view<_CharT>;
      using __string = basic_string<_CharT>;

      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
 {
   auto __first = __pc.begin();
   auto __last = __pc.end();

   _ChronoSpec<_CharT> __spec{};

   auto __finalize = [this, &__spec] {
     _M_spec = __spec;
   };

   auto __finished = [&] {
     if (__first == __last || *__first == '}')
       {
  __finalize();
  return true;
       }
     return false;
   };

   if (__finished())
     return __first;

   __first = __spec._M_parse_fill_and_align(__first, __last);
   if (__finished())
     return __first;

   __first = __spec._M_parse_width(__first, __last, __pc);
   if (__finished())
     return __first;

   if (__parts & _ChronoParts::_Duration)
     {
       __first = __spec._M_parse_precision(__first, __last, __pc);
       if (__finished())
  return __first;
     }

   __first = __spec._M_parse_locale(__first, __last);
   if (__finished())
     return __first;



   {
     __string_view __str(__first, __last - __first);
     auto __end = __str.find('}');
     if (__end != __str.npos)
       {
  __str.remove_suffix(__str.length() - __end);
  __last = __first + __end;
       }
     if (__str.find('{') != __str.npos)
       __throw_format_error("chrono format error: '{' in chrono-specs");
   }





   const auto __chrono_specs = __first++;
   if (*__chrono_specs != '%')
     __throw_format_error("chrono format error: no '%' at start of "
     "chrono-specs");

   _CharT __mod{};
   bool __conv = true;
   int __needed = 0;
   bool __locale_specific = false;

   while (__first != __last)
     {
       enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
       _Mods __allowed_mods = _Mod_none;

       _CharT __c = *__first++;
       switch (__c)
  {
  case 'a':
  case 'A':
    __needed = _Weekday;
    __locale_specific = true;
    break;
  case 'b':
  case 'h':
  case 'B':
    __needed = _Month;
    __locale_specific = true;
    break;
  case 'c':
    __needed = _DateTime;
    __allowed_mods = _Mod_E;
    __locale_specific = true;
    break;
  case 'C':
    __needed = _Year;
    __allowed_mods = _Mod_E;
    break;
  case 'd':
  case 'e':
    __needed = _Day;
    __allowed_mods = _Mod_O;
    break;
  case 'D':
  case 'F':
    __needed = _Date;
    break;
  case 'g':
  case 'G':
    __needed = _Date;
    break;
  case 'H':
  case 'I':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'j':
    if (!(__parts & _Duration))
      __needed = _Date;
    break;
  case 'm':
    __needed = _Month;
    __allowed_mods = _Mod_O;
    break;
  case 'M':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'p':
  case 'r':
    __locale_specific = true;
    [[fallthrough]];
  case 'R':
  case 'T':
    __needed = _TimeOfDay;
    break;
  case 'q':
  case 'Q':
    __needed = _Duration;
    break;
  case 'S':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'u':
  case 'w':
    __needed = _Weekday;
    __allowed_mods = _Mod_O;
    break;
  case 'U':
  case 'V':
  case 'W':
    __needed = _Date;
    __allowed_mods = _Mod_O;
    break;
  case 'x':
    __needed = _Date;
    __locale_specific = true;
    __allowed_mods = _Mod_E;
    break;
  case 'X':
    __needed = _TimeOfDay;
    __locale_specific = true;
    __allowed_mods = _Mod_E;
    break;
  case 'y':
    __needed = _Year;
    __allowed_mods = _Mod_E_O;
    break;
  case 'Y':
    __needed = _Year;
    __allowed_mods = _Mod_E;
    break;
  case 'z':
    __needed = _TimeZone;
    __allowed_mods = _Mod_E_O;
    break;
  case 'Z':
    __needed = _TimeZone;
    break;
  case 'n':
  case 't':
  case '%':
    break;
  case 'O':
  case 'E':
    if (__mod) [[unlikely]]
      {
        __allowed_mods = _Mod_none;
        break;
      }
    __mod = __c;
    continue;
  default:
    __throw_format_error("chrono format error: invalid "
           " specifier in chrono-specs");
  }

       if ((__mod == 'E' && !(__allowed_mods & _Mod_E))
      || (__mod == 'O' && !(__allowed_mods & _Mod_O)))
  __throw_format_error("chrono format error: invalid "
         " modifier in chrono-specs");
       if (__mod && __c != 'z')
  __locale_specific = true;
       __mod = _CharT();

       if ((__parts & __needed) != __needed)
  __throw_format_error("chrono format error: format argument "
         "does not contain the information "
         "required by the chrono-specs");


       size_t __pos = __string_view(__first, __last - __first).find('%');
       if (__pos == 0)
  ++__first;
       else
  {
    if (__pos == __string_view::npos)
      {
        __first = __last;
        __conv = false;
      }
    else
      __first += __pos + 1;
  }
     }


   if (__conv || __mod != _CharT())
     __throw_format_error("chrono format error: unescaped '%' in "
     "chrono-specs");

   _M_spec = __spec;
   _M_spec._M_chrono_specs
   = __string_view(__chrono_specs, __first - __chrono_specs);
   _M_spec._M_locale_specific(__locale_specific);

   return __first;
 }






      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_format(const _Tp& __t, _FormatContext& __fc,
    bool __is_neg = false) const
 {
   auto __first = _M_spec._M_chrono_specs.begin();
   const auto __last = _M_spec._M_chrono_specs.end();
   if (__first == __last)
     return _M_format_to_ostream(__t, __fc, __is_neg);





   if constexpr (is_same_v<_CharT, char>)
     if constexpr (__unicode::__literal_encoding_is_utf8())
       if (_M_spec._M_localized && _M_spec._M_locale_specific())
  {
    extern locale __with_encoding_conversion(const locale&);



    locale __loc = __fc.locale();
    if (__loc != locale::classic())
      __fc._M_loc = __with_encoding_conversion(__loc);
  }


   _Sink_iter<_CharT> __out;
   __format::_Str_sink<_CharT> __sink;
   bool __write_direct = false;
   if constexpr (is_same_v<typename _FormatContext::iterator,
      _Sink_iter<_CharT>>)
     {
       if (_M_spec._M_width_kind == __format::_WP_none)
  {
    __out = __fc.out();
    __write_direct = true;
  }
       else
  __out = __sink.out();
     }
   else
     __out = __sink.out();



   if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     __is_neg = __t.is_negative();

   auto __print_sign = [&__is_neg, &__out] {
     if constexpr (chrono::__is_duration_v<_Tp>
       || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
       if (__is_neg)
  {
    *__out++ = _S_plus_minus[1];
    __is_neg = false;
  }
     return std::move(__out);
   };


   constexpr const _CharT* __literals = ::std::__format::_Widen<_CharT>("\n\t%", L"\n\t%");

   ++__first;

   _CharT __mod{};
   do
     {
       _CharT __c = *__first++;
       switch (__c)
  {
  case 'a':
  case 'A':
    __out = _M_a_A(__t, std::move(__out), __fc, __c == 'A');
    break;
  case 'b':
  case 'h':
  case 'B':
    __out = _M_b_B(__t, std::move(__out), __fc, __c == 'B');
    break;
  case 'c':
  case 'r':
  case 'x':
  case 'X':
    __out = _M_c_r_x_X(__t, std::move(__out), __fc, __c, __mod);
    break;
  case 'C':
  case 'y':
  case 'Y':
    __out = _M_C_y_Y(__t, std::move(__out), __fc, __c, __mod);
    break;
  case 'd':
  case 'e':
    __out = _M_d_e(__t, std::move(__out), __fc, __c, __mod == 'O');
    break;
  case 'D':
    __out = _M_D(__t, std::move(__out), __fc);
    break;
  case 'F':
    __out = _M_F(__t, std::move(__out), __fc);
    break;
  case 'g':
  case 'G':
    __out = _M_g_G(__t, std::move(__out), __fc, __c == 'G');
    break;
  case 'H':
  case 'I':
    __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod == 'O');
    break;
  case 'j':
    __out = _M_j(__t, __print_sign(), __fc);
    break;
  case 'm':
    __out = _M_m(__t, std::move(__out), __fc, __mod == 'O');
    break;
  case 'M':
    __out = _M_M(__t, __print_sign(), __fc, __mod == 'O');
    break;
  case 'p':
    __out = _M_p(__t, std::move(__out), __fc);
    break;
  case 'q':
    __out = _M_q(__t, std::move(__out), __fc);
    break;
  case 'Q':

    if constexpr (chrono::__is_duration_v<_Tp>)


      __out = std::format_to(__print_sign(), _S_empty_spec,
        +__t.count());
    else
      __throw_format_error("chrono format error: argument is "
      "not a duration");
    break;
  case 'R':
  case 'T':
    __out = _M_R_T(__t, __print_sign(), __fc, __c == 'T');
    break;
  case 'S':
    __out = _M_S(__t, __print_sign(), __fc, __mod == 'O');
    break;
  case 'u':
  case 'w':
    __out = _M_u_w(__t, std::move(__out), __fc, __c, __mod == 'O');
    break;
  case 'U':
  case 'V':
  case 'W':
    __out = _M_U_V_W(__t, std::move(__out), __fc, __c,
       __mod == 'O');
    break;
  case 'z':
    __out = _M_z(__t, std::move(__out), __fc, (bool)__mod);
    break;
  case 'Z':
    __out = _M_Z(__t, std::move(__out), __fc);
    break;
  case 'n':
    *__out++ = __literals[0];
    break;
  case 't':
    *__out++ = __literals[1];
    break;
  case '%':
    *__out++ = __literals[2];
    break;
  case 'O':
  case 'E':
    __mod = __c;
    continue;
  case '}':
    __first = __last;
    break;
  }
       __mod = _CharT();

       __string_view __str(__first, __last - __first);
       size_t __pos = __str.find('%');
       if (__pos == 0)
  ++__first;
       else
  {
    if (__pos == __str.npos)
      __first = __last;
    else
      {
        __str.remove_suffix(__str.length() - __pos);
        __first += __pos + 1;
      }
    __out = __format::__write(std::move(__out), __str);
  }
     }
   while (__first != __last);

   if constexpr (is_same_v<typename _FormatContext::iterator,
      _Sink_iter<_CharT>>)
     if (__write_direct)
       return __out;

   auto __span = __sink.view();
   __string_view __str(__span.data(), __span.size());
   size_t __width;
   if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
     __width = __unicode::__field_width(__str);
   else
     __width = __str.size();
   return __format::__write_padded_as_spec(__str, __width,
        __fc, _M_spec);
 }

      _ChronoSpec<_CharT> _M_spec;

    private:

      template<typename _FormatContext>
 std::locale
 _M_locale(_FormatContext& __fc) const
 {
   if (!_M_spec._M_localized)
     return std::locale::classic();
   else
     return __fc.locale();
 }






      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_format_to_ostream(const _Tp& __t, _FormatContext& __fc,
        bool __is_neg) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   basic_ostringstream<_CharT> __os;
   __os.imbue(_M_locale(__fc));

   if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {

       auto __days = chrono::floor<chrono::days>(__t._M_time);
       __os << chrono::year_month_day(__days) << ' '
     << chrono::hh_mm_ss(__t._M_time - __days);



       if (__is_neg)
  {
    if (!__t._M_abbrev) [[unlikely]]
      __format::__no_timezone_available();
    else if constexpr (is_same_v<_CharT, char>)
      __os << ' ' << *__t._M_abbrev;
    else
      {
        __os << L' ';
        for (char __c : *__t._M_abbrev)
   __os << __c;
      }
  }
     }
   else
     {
       if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
  __os << __t._M_date << ' ' << __t._M_time;
       else if constexpr (chrono::__is_time_point_v<_Tp>)
  {





    if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
      __os << _S_date(__t);

    else if constexpr (is_convertible_v<_Tp, chrono::local_days>)
      __os << _S_date(__t);
    else
      {
        auto __days = chrono::floor<chrono::days>(__t);
        __os << chrono::year_month_day(__days) << ' '
    << chrono::hh_mm_ss(__t - __days);
      }
  }
       else
  {
    if constexpr (chrono::__is_duration_v<_Tp>)
      if (__is_neg) [[unlikely]]
        __os << _S_plus_minus[1];
    __os << __t;
  }
     }

   auto __str = std::move(__os).str();
   return __format::__write_padded_as_spec(__str, __str.size(),
        __fc, _M_spec);
 }

      static constexpr const _CharT* _S_chars
 = ::std::__format::_Widen<_CharT>("0123456789+-:/ {}", L"0123456789+-:/ {}");
      static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
      static constexpr _CharT _S_colon = _S_chars[12];
      static constexpr _CharT _S_slash = _S_chars[13];
      static constexpr _CharT _S_space = _S_chars[14];
      static constexpr const _CharT* _S_empty_spec = _S_chars + 15;

      template<typename _OutIter>
 _OutIter
 _M_write(_OutIter __out, const locale& __loc, __string_view __s) const
 {

   __sso_string __buf;



   if constexpr (is_same_v<_CharT, char>)
     if constexpr (__unicode::__literal_encoding_is_utf8())
       if (_M_spec._M_localized && _M_spec._M_locale_specific()
      && __loc != locale::classic())
  {
    extern string_view
    __locale_encoding_to_utf8(const locale&, string_view, void*);

    __s = __locale_encoding_to_utf8(__loc, __s, &__buf);
  }

   return __format::__write(std::move(__out), __s);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_a_A(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __full) const
 {


   chrono::weekday __wd = _S_weekday(__t);
   if (!__wd.ok())
     __throw_format_error("format error: invalid weekday");

   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __days[7];
   if (__full)
     __tp._M_days(__days);
   else
     __tp._M_days_abbreviated(__days);
   __string_view __str(__days[__wd.c_encoding()]);
   return _M_write(std::move(__out), __loc, __str);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_b_B(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __full) const
 {


   chrono::month __m = _S_month(__t);
   if (!__m.ok())
     __throw_format_error("format error: invalid month");
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __months[12];
   if (__full)
     __tp._M_months(__months);
   else
     __tp._M_months_abbreviated(__months);
   __string_view __str(__months[(unsigned)__m - 1]);
   return _M_write(std::move(__out), __loc, __str);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_c_r_x_X(const _Tp& __t, typename _FormatContext::iterator __out,
     _FormatContext& __ctx, _CharT __conv, _CharT __mod) const
 {
# 890 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
   using namespace chrono;
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   struct tm __tm{};





   __tm.tm_isdst = -1;




   if constexpr (__is_time_point_v<_Tp>)
     {

       if constexpr (!is_same_v<typename _Tp::clock, local_t>)
  __tm.tm_zone = const_cast<char*>("UTC");
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {


       if (__t._M_abbrev)
  __tm.tm_zone = const_cast<char*>(__t._M_abbrev->c_str());
     }
   else
     __tm.tm_zone = const_cast<char*>("UTC");


   if (__conv == 'c' || __conv == 'x')
   {
     auto __d = _S_days(__t);
     using _TDays = decltype(__d);
     const year_month_day __ymd(__d);
     const auto __y = __ymd.year();

     __tm.tm_year = (int)__y - 1900;
     __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
     __tm.tm_mon = (unsigned)__ymd.month() - 1;
     __tm.tm_mday = (unsigned)__ymd.day();
     __tm.tm_wday = weekday(__d).c_encoding();
   }

   if (__conv != 'x')
   {
     const auto __hms = _S_hms(__t);
     __tm.tm_hour = __hms.hours().count();
     __tm.tm_min = __hms.minutes().count();
     __tm.tm_sec = __hms.seconds().count();
   }

   return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
          __conv, __mod);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_C_y_Y(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0) const
 {
# 961 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
   chrono::year __y = _S_year(__t);

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_year = (int)__y - 1900;
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         __conv, __mod);
       }

   basic_string<_CharT> __s;
   int __yi = (int)__y;
   const bool __is_neg = __yi < 0;
   __yi = __builtin_abs(__yi);

   if (__conv == 'Y' || __conv == 'C')
     {
       int __ci = __yi / 100;
       if (__is_neg) [[unlikely]]
  {
    __s.assign(1, _S_plus_minus[1]);

    if (__conv == 'C' && (__ci * 100) != __yi)
      ++__ci;
  }
       if (__ci >= 100) [[unlikely]]
  {
    __s += std::format(_S_empty_spec, __ci / 100);
    __ci %= 100;
  }
       __s += _S_two_digits(__ci);
     }

   if (__conv == 'Y' || __conv == 'y')
     __s += _S_two_digits(__yi % 100);

   return __format::__write(std::move(__out), __string_view(__s));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_D(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   auto __ymd = _S_date(__t);
   basic_string<_CharT> __s;



   __s = _S_two_digits((unsigned)__ymd.month());
   __s += _S_slash;
   __s += _S_two_digits((unsigned)__ymd.day());
   __s += _S_slash;
   __s += _S_two_digits(__builtin_abs((int)__ymd.year()) % 100);
   return __format::__write(std::move(__out), __string_view(__s));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_d_e(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   chrono::day __d = _S_day(__t);
   unsigned __i = (unsigned)__d;

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_mday = __i;
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         (char)__conv, 'O');
       }

   auto __sv = _S_two_digits(__i);
   _CharT __buf[2];
   if (__conv == _CharT('e') && __i < 10)
     {
       __buf[0] = _S_space;
       __buf[1] = __sv[1];
       __sv = {__buf, 2};
     }
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_F(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   auto __ymd = _S_date(__t);
   auto __s = std::format(::std::__format::_Widen<_CharT>("{:04d}-  -  ", L"{:04d}-  -  "),
     (int)__ymd.year());
   auto __sv = _S_two_digits((unsigned)__ymd.month());
   __s[__s.size() - 5] = __sv[0];
   __s[__s.size() - 4] = __sv[1];
   __sv = _S_two_digits((unsigned)__ymd.day());
   __s[__s.size() - 2] = __sv[0];
   __s[__s.size() - 1] = __sv[1];
   __sv = __s;
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_g_G(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __full) const
 {


   using namespace chrono;
   auto __d = _S_days(__t);

   __d -= (weekday(__d) - Monday) - days(3);

   year __y = year_month_day(__d).year();
   return _M_C_y_Y(__y, std::move(__out), __ctx, "yY"[__full]);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_H_I(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   const auto __hms = _S_hms(__t);
   int __i = __hms.hours().count();

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_hour = __i;
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         (char)__conv, 'O');
       }

   if (__conv == _CharT('I'))
     {
       if (__i == 0)
  __i = 12;
       else if (__i > 12)
  __i -= 12;
     }
   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_j(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   if constexpr (chrono::__is_duration_v<_Tp>)
     {

       unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
       return std::format_to(std::move(__out), _S_empty_spec, __d);
     }
   else
     {

       using namespace chrono;
       auto __day = _S_days(__t);
       auto __ymd = _S_date(__t);
       days __d;


       if constexpr (is_same_v<typename decltype(__day)::clock, local_t>)
  __d = __day - local_days(__ymd.year()/January/0);
       else
  __d = __day - sys_days(__ymd.year()/January/0);
       return std::format_to(std::move(__out), ::std::__format::_Widen<_CharT>("{:03d}", L"{:03d}"),
        __d.count());
     }
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_m(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod) const
 {



   auto __m = _S_month(__t);
   auto __i = (unsigned)__m;

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_mon = __i - 1;
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         'm', 'O');
       }

   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_M(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod) const
 {



   auto __m = _S_hms(__t).minutes();
   auto __i = __m.count();

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_min = __i;
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         'M', 'O');
       }

   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_p(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx) const
 {

   auto __hms = _S_hms(__t);
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __ampm[2];
   __tp._M_am_pm(__ampm);
   return _M_write(std::move(__out), __loc,
     __ampm[__hms.hours().count() >= 12]);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_q(const _Tp&, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {

   if constexpr (!chrono::__is_duration_v<_Tp>)
     __throw_format_error("format error: argument is not a duration");
   else
     {
       namespace __d = chrono::__detail;
       using period = typename _Tp::period;
       return __d::__fmt_units_suffix<period, _CharT>(std::move(__out));
     }
 }



      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_R_T(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __secs) const
 {


   auto __hms = _S_hms(__t);

   auto __s = std::format(::std::__format::_Widen<_CharT>("{:02d}:00", L"{:02d}:00"),
     __hms.hours().count());
   auto __sv = _S_two_digits(__hms.minutes().count());
   __s[__s.size() - 2] = __sv[0];
   __s[__s.size() - 1] = __sv[1];
   __sv = __s;
   __out = __format::__write(std::move(__out), __sv);
   if (__secs)
     {
       *__out++ = _S_colon;
       __out = _M_S(__hms, std::move(__out), __ctx);
     }
   return __out;
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_S(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod = false) const
 {


   auto __hms = _S_hms(__t);
   auto __s = __hms.seconds();

   if (__mod) [[unlikely]]
     {
       if (_M_spec._M_localized)
  if (auto __loc = __ctx.locale(); __loc != locale::classic())
    {
      struct tm __tm{};
      __tm.tm_sec = (int)__s.count();
      return _M_locale_fmt(std::move(__out), __loc, __tm,
      'S', 'O');
    }


       return __format::__write(std::move(__out),
           _S_two_digits(__s.count()));
     }

   if constexpr (__hms.fractional_width == 0)
     __out = __format::__write(std::move(__out),
          _S_two_digits(__s.count()));
   else
     {
       locale __loc = _M_locale(__ctx);
       auto __ss = __hms.subseconds();
       using rep = typename decltype(__ss)::rep;
       if constexpr (is_floating_point_v<rep>)
  {
    chrono::duration<rep> __fs = __s + __ss;
    __out = std::format_to(std::move(__out), __loc,
      ::std::__format::_Widen<_CharT>("{:#0{}.{}Lf}", L"{:#0{}.{}Lf}"),
      __fs.count(),
      3 + __hms.fractional_width,
      __hms.fractional_width);
  }
       else
  {
    const auto& __np
      = use_facet<numpunct<_CharT>>(__loc);
    __out = __format::__write(std::move(__out),
         _S_two_digits(__s.count()));
    *__out++ = __np.decimal_point();
    if constexpr (is_integral_v<rep>)
      __out = std::format_to(std::move(__out),
        ::std::__format::_Widen<_CharT>("{:0{}}", L"{:0{}}"),
        __ss.count(),
        __hms.fractional_width);
    else
      {
        auto __str = std::format(_S_empty_spec, __ss.count());
        __out = std::format_to(std::move(__out),
          ::std::__format::_Widen<_CharT>("{:0>{}s}", L"{:0>{}s}"),
          __str,
          __hms.fractional_width);
      }
  }
     }
   return __out;
 }



      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_u_w(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   chrono::weekday __wd = _S_weekday(__t);

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  struct tm __tm{};
  __tm.tm_wday = __wd.c_encoding();
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         (char)__conv, 'O');
       }

   unsigned __wdi = __conv == 'u' ? __wd.iso_encoding()
      : __wd.c_encoding();
   const _CharT __d = _S_digit(__wdi);
   return __format::__write(std::move(__out), __string_view(&__d, 1));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out,
   _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {






   using namespace chrono;
   auto __d = _S_days(__t);
   using _TDays = decltype(__d);

   if (__mod && _M_spec._M_localized) [[unlikely]]
     if (auto __loc = __ctx.locale(); __loc != locale::classic())
       {
  const year_month_day __ymd(__d);
  const year __y = __ymd.year();
  struct tm __tm{};
  __tm.tm_year = (int)__y - 1900;
  __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
  __tm.tm_wday = weekday(__d).c_encoding();
  return _M_locale_fmt(std::move(__out), __loc, __tm,
         (char)__conv, 'O');
       }

   _TDays __first;
   if (__conv == 'V')
     {

       __d -= (weekday(__d) - Monday) - days(3);


       __first = _TDays(year_month_day(__d).year()/January/1);
     }
   else
     {
       year __y;
       if constexpr (requires { __t.year(); })
  __y = __t.year();
       else
  __y = year_month_day(__d).year();
       const weekday __weekstart = __conv == 'U' ? Sunday : Monday;
       __first = _TDays(__y/January/__weekstart[1]);
     }
   auto __weeks = chrono::floor<weeks>(__d - __first);
   __string_view __sv = _S_two_digits(__weeks.count() + 1);
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_z(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&, bool __mod = false) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   auto __utc = __mod ? __string_view(::std::__format::_Widen<_CharT>("+00:00", L"+00:00"), 6)
        : __string_view(::std::__format::_Widen<_CharT>("+0000", L"+0000"), 5);

   if constexpr (chrono::__is_time_point_v<_Tp>)
     {
       if constexpr (is_same_v<typename _Tp::clock,
          chrono::system_clock>)
  return __format::__write(std::move(__out), __utc);
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {
       if (__t._M_offset_sec)
  {
    auto __sv = __utc;
    basic_string<_CharT> __s;
    if (*__t._M_offset_sec != 0s)
      {
        chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
        __s = _S_plus_minus[__hms.is_negative()];
        __s += _S_two_digits(__hms.hours().count());
        if (__mod)
   __s += _S_colon;
        __s += _S_two_digits(__hms.minutes().count());
        __sv = __s;
      }
    return __format::__write(std::move(__out), __sv);
  }
     }
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __format::__write(std::move(__out), __utc);

   __no_timezone_available();
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_Z(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   __string_view __utc(::std::__format::_Widen<_CharT>("UTC", L"UTC"), 3);
   if constexpr (chrono::__is_time_point_v<_Tp>)
     {
       if constexpr (is_same_v<typename _Tp::clock,
          chrono::system_clock>)
  return __format::__write(std::move(__out), __utc);
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {
       if (__t._M_abbrev)
  {
    string_view __sv = *__t._M_abbrev;
    if constexpr (is_same_v<_CharT, char>)
      return __format::__write(std::move(__out), __sv);
    else
      {

        basic_string<_CharT> __ws(__sv.size(), _CharT());
        auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
        __ct.widen(__sv.begin(), __sv.end(), __ws.data());
        __string_view __wsv = __ws;
        return __format::__write(std::move(__out), __wsv);
      }
  }
     }
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __format::__write(std::move(__out), __utc);

   __no_timezone_available();
 }




      static _CharT
      _S_digit(int __n) noexcept
      {

 return ::std::__format::_Widen<_CharT>("0123456789999999", L"0123456789999999")[__n & 0xf];
      }


      static basic_string_view<_CharT>
      _S_two_digits(int __n) noexcept
      {
 return {
   ::std::__format::_Widen<_CharT>("0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899" "9999999999999999999999999999999999999999" "9999999999999999", L"0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899" "9999999999999999999999999999999999999999" "9999999999999999") + 2 * (__n & 0x7f),






   2
 };
      }




      template<typename _Tp>
 static decltype(auto)
 _S_hms(const _Tp& __t)
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     return __t;
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __t._M_time;
   else if constexpr (chrono::__is_duration_v<_Tp>)
     return chrono::hh_mm_ss<_Tp>(__t);
   else if constexpr (chrono::__is_time_point_v<_Tp>)
     return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return _S_hms(__t._M_time);
   else
     {
       __invalid_chrono_spec();
       return chrono::hh_mm_ss<chrono::seconds>();
     }
 }


      template<typename _Tp>
 static auto
 _S_days(const _Tp& __t)
 {
   using namespace chrono;
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (__is_time_point_v<_Tp>)
     return chrono::floor<days>(__t);
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __t._M_date;
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return chrono::floor<days>(__t._M_time);
   else if constexpr (is_same_v<_Tp, year_month_day>
          || is_same_v<_Tp, year_month_day_last>
          || is_same_v<_Tp, year_month_weekday>
          || is_same_v<_Tp, year_month_weekday_last>)
     return sys_days(__t);
   else
     {
       if constexpr (__is_duration_v<_Tp>)
  __not_valid_for_duration();
       else
  __invalid_chrono_spec();
       return chrono::sys_days();
     }
 }


      template<typename _Tp>
 static chrono::year_month_day
 _S_date(const _Tp& __t)
 {
   if constexpr (is_same_v<_Tp, chrono::year_month_day>)
     return __t;
   else
     return chrono::year_month_day(_S_days(__t));
 }

      template<typename _Tp>
 static chrono::day
 _S_day(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, day>)
     return __t;
   else if constexpr (requires { __t.day(); })
     return __t.day();
   else
     return _S_date(__t).day();
 }

      template<typename _Tp>
 static chrono::month
 _S_month(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, month>)
     return __t;
   else if constexpr (requires { __t.month(); })
     return __t.month();
   else
     return _S_date(__t).month();
 }

      template<typename _Tp>
 static chrono::year
 _S_year(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, year>)
     return __t;
   else if constexpr (requires { __t.year(); })
     return __t.year();
   else
     return _S_date(__t).year();
 }

      template<typename _Tp>
 static chrono::weekday
 _S_weekday(const _Tp& __t)
 {
   using namespace ::std::chrono;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (is_same_v<_Tp, weekday>)
     return __t;
   else if constexpr (requires { __t.weekday(); })
     return __t.weekday();
   else if constexpr (is_same_v<_Tp, month_weekday>)
     return __t.weekday_indexed().weekday();
   else if constexpr (is_same_v<_Tp, month_weekday_last>)
     return __t.weekday_last().weekday();
   else
     return weekday(_S_days(__t));
 }


      template<typename _Tp>
 static auto
 _S_floor_seconds(const _Tp& __t)
 {
   using chrono::__detail::__local_time_fmt;
   if constexpr (chrono::__is_time_point_v<_Tp>
     || chrono::__is_duration_v<_Tp>)
     {
       if constexpr (_Tp::period::den != 1)
  return chrono::floor<chrono::seconds>(__t);
       else
  return __t;
     }
   else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     {
       if constexpr (_Tp::fractional_width != 0)
  return chrono::floor<chrono::seconds>(__t.to_duration());
       else
  return __t;
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return _S_floor_seconds(__t._M_time);
   else
     return __t;
 }



      template<typename _Iter>
 _Iter
 _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
        char __fmt, char __mod) const
 {
   basic_ostringstream<_CharT> __os;
   __os.imbue(__loc);
   const auto& __tp = use_facet<time_put<_CharT>>(__loc);
   __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
   if (__os)
     __out = _M_write(std::move(__out), __loc, __os.view());
   return __out;
 }
    };

}


  template<typename _Rep, typename _Period, typename _CharT>
    requires __format::__formattable_impl<_Rep, _CharT>
    struct formatter<chrono::duration<_Rep, _Period>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 using namespace __format;
 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
 if constexpr (!is_floating_point_v<_Rep>)
   if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
     __throw_format_error("format error: invalid precision for duration");
 return __it;
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::duration<_Rep, _Period>& __d,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   if constexpr (numeric_limits<_Rep>::is_signed)
     if (__d < __d.zero()) [[unlikely]]
       {
  if constexpr (is_integral_v<_Rep>)
    {


      using _URep = make_unsigned_t<_Rep>;
      auto __ucnt = -static_cast<_URep>(__d.count());
      auto __ud = chrono::duration<_URep, _Period>(__ucnt);
      return _M_f._M_format(__ud, __fc, true);
    }
  else
    return _M_f._M_format(-__d, __fc, true);
       }
   return _M_f._M_format(__d, __fc, false);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Day); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::day& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::month, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Month); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::month& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Year); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::weekday& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::weekday_indexed, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::weekday_indexed& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::weekday_last& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::month_day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::month_day& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::month_day_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Month); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::month_day_last& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::month_weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::month_weekday& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::month_weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::month_weekday_last& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year_month, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year_month& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year_month_day, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year_month_day& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year_month_day_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year_month_day_last& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year_month_weekday, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year_month_weekday& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::year_month_weekday_last, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::year_month_weekday_last& __t,
        basic_format_context<_Out, _CharT>& __fc) const
       { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Rep, typename _Period, __format::__char _CharT>
    struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_TimeOfDay); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<__format::__char _CharT>
    struct formatter<chrono::sys_info, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::sys_info& __i,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__i, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<chrono::local_info, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::local_info& __i,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__i, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::sys_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
 if constexpr (!__stream_insertable)
   if (_M_f._M_spec._M_chrono_specs.empty())
     __format::__invalid_chrono_spec();
 return __next;
     }

     template<typename _Out>
       typename basic_format_context<_Out, _CharT>::iterator
       format(const chrono::sys_time<_Duration>& __t,
       basic_format_context<_Out, _CharT>& __fc) const
       { return _M_f._M_format(__t, __fc); }

    private:
      static constexpr bool __stream_insertable
 = requires (basic_ostream<_CharT>& __os,
      chrono::sys_time<_Duration> __t) { __os << __t; };

      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::utc_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::utc_time<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 {



   using chrono::__detail::__utc_leap_second;
   using chrono::seconds;
   using chrono::sys_time;
   using _CDur = common_type_t<_Duration, seconds>;
   const auto __li = chrono::get_leap_second_info(__t);
   sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
   if (!__li.is_leap_second) [[likely]]
     return _M_f._M_format(__s, __fc);
   else
     return _M_f._M_format(__utc_leap_second(__s), __fc);
 }

    private:
      friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;

      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::tai_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::tai_time<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 {





   constexpr chrono::days __tai_offset = chrono::days(4383);
   using _CDur = common_type_t<_Duration, chrono::days>;
   chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
   const string __abbrev("TAI", 3);
   const chrono::seconds __off = 0s;
   const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
   return _M_f._M_format(__lf, __fc);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::gps_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::gps_time<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 {





   constexpr chrono::days __gps_offset = chrono::days(3657);
   using _CDur = common_type_t<_Duration, chrono::days>;
   chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
   const string __abbrev("GPS", 3);
   const chrono::seconds __off = 0s;
   const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
   return _M_f._M_format(__lf, __fc);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::file_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::file_time<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   using namespace chrono;
   return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __fc);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::local_time<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_DateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::local_time<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::__detail::__local_time_fmt<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f._M_format(__t, __fc, true); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<typename _Duration, typename _TimeZonePtr, __format::__char _CharT>
    struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
    : formatter<chrono::__detail::__local_time_fmt_for<_Duration>, _CharT>
    {
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   using _Ltf = chrono::__detail::__local_time_fmt_for<_Duration>;
   using _Base = formatter<_Ltf, _CharT>;
   const chrono::sys_info __info = __tp.get_info();
   const auto __lf = chrono::local_time_format(__tp.get_local_time(),
            &__info.abbrev,
            &__info.offset);
   return _Base::format(__lf, __fc);
 }
    };



  template<typename _Duration, __format::__char _CharT>
    struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
    : formatter<chrono::utc_time<_Duration>, _CharT>
    {
      template<typename _Out>
        typename basic_format_context<_Out, _CharT>::iterator
        format(const chrono::__detail::__utc_leap_second<_Duration>& __t,
        basic_format_context<_Out, _CharT>& __fc) const
 { return this->_M_f._M_format(__t, __fc); }
    };

namespace chrono
{




namespace __detail
{
  template<typename _Duration = seconds>
    struct _Parser
    {
      static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);

      explicit
      _Parser(__format::_ChronoParts __need) : _M_need(__need) { }

      _Parser(_Parser&&) = delete;
      void operator=(_Parser&&) = delete;

      _Duration _M_time{};
      sys_days _M_sys_days{};
      year_month_day _M_ymd{};
      weekday _M_wd{};
      __format::_ChronoParts _M_need;
      unsigned _M_is_leap_second : 1 {};
      unsigned _M_reserved : 15 {};

      template<typename _CharT, typename _Traits, typename _Alloc>
 basic_istream<_CharT, _Traits>&
 operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
     basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
     minutes* __offset = nullptr);

    private:


      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
    ios_base::iostate& __err, int __n)
 {
   int_least32_t __val = _S_try_read_digit(__is, __err);
   if (__val == -1) [[unlikely]]
     __err |= ios_base::failbit;
   else
     {
       int __n1 = (std::min)(__n, 9);

       for (int __i = 1; __i < __n1; ++__i)
  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
    {
      __val *= 10;
      __val += __dig;
    }

       while (__n1++ < __n) [[unlikely]]
  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
    {
      if (__builtin_mul_overflow(__val, 10, &__val)
     || __builtin_add_overflow(__val, __dig, &__val))
        {
   __err |= ios_base::failbit;
   return -1;
        }
    }
     }
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
    ios_base::iostate& __err, int __n)
 {
   auto __sign = __is.peek();
   if (__sign == '-' || __sign == '+')
     (void) __is.get();
   int_least32_t __val = _S_read_unsigned(__is, __err, __n);
   if (__err & ios_base::failbit)
     {
       if (__sign == '-') [[unlikely]]
  __val *= -1;
     }
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
     ios_base::iostate& __err)
 {
   int_least32_t __val = -1;
   auto __i = __is.peek();
   if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
     {
       _CharT __c = _Traits::to_char_type(__i);
       if (_CharT('0') <= __c && __c <= _CharT('9')) [[likely]]
  {
    (void) __is.get();
    __val = __c - _CharT('0');
  }
     }
   else
     __err |= ios_base::eofbit;
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static bool
 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
      ios_base::iostate& __err, _CharT __c)
 {
   auto __i = __is.peek();
   if (_Traits::eq_int_type(__i, _Traits::eof()))
     __err |= ios_base::eofbit;
   else if (_Traits::to_char_type(__i) == __c) [[likely]]
     {
       (void) __is.get();
       return true;
     }
   __err |= ios_base::failbit;
   return false;
 }
    };

  template<typename _Duration>
    using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;

  template<typename _Duration>
    consteval bool
    __use_floor()
    {
      if constexpr (_Duration::period::den == 1)
 {
   switch (_Duration::period::num)
   {
     case minutes::period::num:
     case hours::period::num:
     case days::period::num:
     case weeks::period::num:
     case years::period::num:
       return true;
   }
 }
      return false;
    }
# 2405 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
  template<typename _ToDur, typename _Tp>
    constexpr auto
    __round(const _Tp& __t)
    {
      if constexpr (__is_duration_v<_Tp>)
 {
   if constexpr (treat_as_floating_point_v<typename _Tp::rep>)
     return chrono::duration_cast<_ToDur>(__t);
   else if constexpr (__detail::__use_floor<_ToDur>())
     return chrono::floor<_ToDur>(__t);
   else
     return chrono::round<_ToDur>(__t);
 }
      else
 {
   static_assert(__is_time_point_v<_Tp>);
   using _Tpt = time_point<typename _Tp::clock, _ToDur>;
   return _Tpt(__detail::__round<_ToDur>(__t.time_since_epoch()));
 }
    }

}


  template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  duration<_Rep, _Period>& __d,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      auto __need = __format::_ChronoParts::_TimeOfDay;
      __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __d = __detail::__round<duration<_Rep, _Period>>(__p._M_time);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::__format::_Widen<_CharT>("{:02d} is not a valid day", L"{:02d} is not a valid day");
      if (__d.ok())
 __s = __s.substr(0, 6);
      auto __u = (unsigned)__d;
      __os << std::vformat(__s, make_format_args<_Ctx>(__u));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  day& __d,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Day);
      if (__p(__is, __fmt, __abbrev, __offset))
 __d = __p._M_ymd.day();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::__format::_Widen<_CharT>("{:L%b}{} is not a valid month", L"{:L%b}{} is not a valid month");
      if (__m.ok())
 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
        make_format_args<_Ctx>(__m));
      else
 {
   auto __u = (unsigned)__m;
   __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
 }
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  month& __m,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Month);
      if (__p(__is, __fmt, __abbrev, __offset))
 __m = __p._M_ymd.month();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::__format::_Widen<_CharT>("-{:04d} is not a valid year", L"-{:04d} is not a valid year");
      if (__y.ok())
 __s = __s.substr(0, 7);
      int __i = (int)__y;
      if (__i >= 0) [[likely]]
 __s.remove_prefix(1);
      else
 __i = -__i;
      __os << std::vformat(__s, make_format_args<_Ctx>(__i));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year& __y,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Year);
      if (__p(__is, __fmt, __abbrev, __offset))
 __y = __p._M_ymd.year();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::__format::_Widen<_CharT>("{:L%a}{} is not a valid weekday", L"{:L%a}{} is not a valid weekday");
      if (__wd.ok())
 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
        make_format_args<_Ctx>(__wd));
      else
 {
   auto __c = __wd.c_encoding();
   __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
 }
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  weekday& __wd,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
      if (__p(__is, __fmt, __abbrev, __offset))
 __wd = __p._M_wd;
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const weekday_indexed& __wdi)
    {



      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdi.weekday();
      const auto __i = __wdi.index();
      basic_string_view<_CharT> __s
 = ::std::__format::_Widen<_CharT>("[ is not a valid index]", L"[ is not a valid index]");
      __os2 << __s[0];
      __os2 << std::format(::std::__format::_Widen<_CharT>("{}", L"{}"), __i);
      if (__i >= 1 && __i <= 5)
 __os2 << __s.back();
      else
 __os2 << __s.substr(1);
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const weekday_last& __wdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdl.weekday() << ::std::__format::_Widen<_CharT>("[last]", L"[last]");
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __md.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __md.day();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  month_day& __md,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_day_last& __mdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mdl.month() << ::std::__format::_Widen<_CharT>("/last", L"/last");
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_weekday& __mwd)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwd.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __mwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_weekday_last& __mwdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwdl.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __mwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ym.year();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __ym.month();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year_month& __ym,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_day& __ymd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::__format::_Widen<_CharT>("{:%F} is not a valid date", L"{:%F} is not a valid date");
      __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
      make_format_args<_Ctx>(__ymd));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year_month_day& __ymd,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __ymd = __p._M_ymd;
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_day_last& __ymdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ymdl.year();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __ymdl.month_day_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_weekday& __ymwd)
    {


      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
 __slash = '/';
      else
 __slash = L'/';
      __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
     << __ymwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_weekday_last& __ymwdl)
    {


      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
 __slash = '/';
      else
 __slash = L'/';
      __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
     << __ymwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const hh_mm_ss<_Duration>& __hms)
    {
      return __os << format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%T}", L"{:L%T}"), __hms);
    }



  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
    {
      __os << '[' << __i.begin << ',' << __i.end
    << ',' << hh_mm_ss(__i.offset) << ',' << __i.save
    << ',' << __i.abbrev << ']';
      return __os;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
    {
      __os << '[';
      if (__li.result == local_info::unique)
 __os << __li.first;
      else
 {
   if (__li.result == local_info::nonexistent)
     __os << "nonexistent";
   else
     __os << "ambiguous";
   __os << " local time between " << __li.first;
   __os << " and " << __li.second;
 }
      __os << ']';
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _TimeZonePtr>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const zoned_time<_Duration, _TimeZonePtr>& __t)
    {
      __os << format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T %Z}", L"{:L%F %T %Z}"), __t);
      return __os;
    }


  template<typename _CharT, typename _Traits, typename _Duration>
    requires (!treat_as_floating_point_v<typename _Duration::rep>)
      && ratio_less_v<typename _Duration::period, days::period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const sys_time<_Duration>& __tp)
    {
      __os << std::format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __tp);
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
    {
      __os << year_month_day{__dp};
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  sys_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       auto __st = __p._M_sys_days + __p._M_time - *__offset;
       __tp = __detail::__round<_Duration>(__st);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const utc_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  utc_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {


   auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
   - *__offset;
   __tp = __detail::__round<_Duration>(__ut);
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const tai_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  tai_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       constexpr sys_days __epoch(-days(4383));
       auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
       tai_time<common_type_t<_Duration, seconds>> __tt(__d);
       __tp = __detail::__round<_Duration>(__tt);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const gps_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  gps_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       constexpr sys_days __epoch(days(3657));
       auto __d = __p._M_sys_days - __epoch + __p._M_time - *__offset;
       gps_time<common_type_t<_Duration, seconds>> __gt(__d);
       __tp = __detail::__round<_Duration>(__gt);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const file_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::__format::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  file_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      sys_time<_Duration> __st;
      if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
 __tp = __detail::__round<_Duration>(file_clock::from_sys(__st));
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const local_time<_Duration>& __lt)
    {
      __os << sys_time<_Duration>{__lt.time_since_epoch()};
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  local_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   days __d = __p._M_sys_days.time_since_epoch();
   auto __t = local_days(__d) + __p._M_time;
   __tp = __detail::__round<_Duration>(__t);
 }
      return __is;
    }



namespace __detail
{


  void from_stream() = delete;

  template<typename _Parsable, typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename... _OptArgs>
    concept __parsable = requires (basic_istream<_CharT, _Traits>& __is,
       const _CharT* __fmt, _Parsable& __tp,
       _OptArgs*... __args)
    { from_stream(__is, __fmt, __tp, __args...); };

  template<typename _Parsable, typename _CharT,
    typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT>>
    struct _Parse
    {
    private:
      using __string_type = basic_string<_CharT, _Traits, _Alloc>;

    public:
      _Parse(const _CharT* __fmt, _Parsable& __tp,
      basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
      minutes* __offset = nullptr)
      : _M_fmt(__fmt), _M_tp(std::__addressof(__tp)),
 _M_abbrev(__abbrev), _M_offset(__offset)
      { }

      _Parse(_Parse&&) = delete;
      _Parse& operator=(_Parse&&) = delete;

    private:
      using __stream_type = basic_istream<_CharT, _Traits>;

      const _CharT* const _M_fmt;
      _Parsable* const _M_tp;
      __string_type* const _M_abbrev;
      minutes* const _M_offset;

      friend __stream_type&
      operator>>(__stream_type& __is, _Parse&& __p)
      {
 if (__p._M_offset)
   from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
        __p._M_offset);
 else if (__p._M_abbrev)
   from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
 else
   from_stream(__is, __p._M_fmt, *__p._M_tp);
 return __is;
      }

      friend void operator>>(__stream_type&, _Parse&) = delete;
      friend void operator>>(__stream_type&, const _Parse&) = delete;
    };
}

  template<typename _CharT, __detail::__parsable<_CharT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp)
    { return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }

  template<typename _CharT, typename _Traits, typename _Alloc,
    __detail::__parsable<_CharT, _Traits> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
          __pa);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, __pa);
    }

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _StrT = basic_string<_CharT, _Traits>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp, minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp, nullptr,
       &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, nullptr,
          &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
          __pa,
          &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, __pa,
          &__offset);
    }


  template<typename _Duration>
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    __detail::_Parser<_Duration>::
    operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
        basic_string<_CharT, _Traits, _Alloc>* __abbrev,
        minutes* __offset)
    {
      using sentry = typename basic_istream<_CharT, _Traits>::sentry;
      ios_base::iostate __err = ios_base::goodbit;
      if (sentry __cerb(__is, true); __cerb)
 {
   locale __loc = __is.getloc();
   auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
   auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);


   struct _Stream_state
   {
     explicit
     _Stream_state(basic_istream<_CharT, _Traits>& __i)
     : _M_is(__i),
       _M_flags(__i.flags(ios_base::skipws | ios_base::dec)),
       _M_w(__i.width(0))
     { }

     ~_Stream_state()
     {
       _M_is.flags(_M_flags);
       _M_is.width(_M_w);
     }

     _Stream_state(_Stream_state&&) = delete;

     basic_istream<_CharT, _Traits>& _M_is;
     ios_base::fmtflags _M_flags;
     streamsize _M_w;
   };

   auto __is_failed = [](ios_base::iostate __e) {
     return static_cast<bool>(__e & ios_base::failbit);
   };



   auto __read_unsigned = [&] (int __n) {
     return _S_read_unsigned(__is, __err, __n);
   };



   auto __read_signed = [&] (int __n) {
     return _S_read_signed(__is, __err, __n);
   };


   auto __read_chr = [&__is, &__err] (_CharT __c) {
     return _S_read_chr(__is, __err, __c);
   };

   using __format::_ChronoParts;
   _ChronoParts __parts{};

   const year __bad_y = --year::min();
   const month __bad_mon(255);
   const day __bad_day(255);
   const weekday __bad_wday(255);
   const hours __bad_h(-1);
   const minutes __bad_min(-9999);
   const seconds __bad_sec(-1);

   year __y = __bad_y, __yy = __bad_y;
   year __iso_y = __bad_y, __iso_yy = __bad_y;
   month __m = __bad_mon;
   day __d = __bad_day;
   weekday __wday = __bad_wday;
   hours __h = __bad_h, __h12 = __bad_h;
   minutes __min = __bad_min;
   _Duration __s = __bad_sec;
   int __ampm = 0;
   int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
   int __century = -1;
   int __dayofyear = -1;

   minutes __tz_offset = __bad_min;
   basic_string<_CharT, _Traits> __tz_abbr;

   if ((_M_need & _ChronoParts::_TimeOfDay)
  && (_M_need & _ChronoParts::_Year))
     {



       __h = hours(0);
       __parts = _ChronoParts::_TimeOfDay;
     }



   _CharT __mod{};
   unsigned __num = 0;
   bool __is_flag = false;

   constexpr bool __is_floating
     = treat_as_floating_point_v<typename _Duration::rep>;
# 3349 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
   while (*__fmt)
     {
       _CharT __c = *__fmt++;
       if (!__is_flag)
  {
    if (__c == '%')
      __is_flag = true;
    else if (std::isspace(__c, __loc))
      std::ws(__is);
    else if (!__read_chr(__c)) [[unlikely]]
      break;

    continue;
  }


       switch (__c)
       {
  case 'a':
  case 'A':
    if (__mod || __num) [[unlikely]]
      __err = ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __wday = weekday(__tm.tm_wday);
      }
    __parts |= _ChronoParts::_Weekday;
    break;

  case 'b':
  case 'h':
  case 'B':
    if (__mod || __num) [[unlikely]]
      __err = ios_base::failbit;
    else
      {



        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __m = month(__tm.tm_mon + 1);
      }
    __parts |= _ChronoParts::_Month;
    break;

  case 'c':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __y = year(__tm.tm_year + 1900);
     __m = month(__tm.tm_mon + 1);
     __d = day(__tm.tm_mday);
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_DateTime;
    break;

  case 'C':
    if (!__mod) [[likely]]
      {
        auto __v = __read_signed(__num ? __num : 2);
        if (!__is_failed(__err))
   {
     int __cmin = (int)year::min() / 100;
     int __cmax = (int)year::max() / 100;
     if (__cmin <= __v && __v <= __cmax)
       __century = __v * 100;
     else
       __century = -2;
   }
      }
    else if (__mod == 'E')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __century = __tm.tm_year;
      }
    else [[unlikely]]
      __err |= ios_base::failbit;

    break;

  case 'd':
  case 'e':
    if (!__mod) [[likely]]
      {
        auto __v = __read_unsigned(__num ? __num : 2);
        if (!__is_failed(__err))
   __d = day(__v);
      }
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __d = day(__tm.tm_mday);
      }
    else [[unlikely]]
      __err |= ios_base::failbit;
    __parts |= _ChronoParts::_Day;
    break;

  case 'D':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __month = __read_unsigned(2);
        __read_chr('/');
        auto __day = __read_unsigned(2);
        __read_chr('/');
        auto __year = __read_unsigned(2);
        if (__is_failed(__err))
   break;
        __y = year(__year + 1900 + 100 * int(__year < 69));
        __m = month(__month);
        __d = day(__day);
        if (!year_month_day(__y, __m, __d).ok())
   {
     __y = __yy = __iso_y = __iso_yy = __bad_y;
     __m = __bad_mon;
     __d = __bad_day;
     break;
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'F':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __year = __read_signed(__num ? __num : 4);
        __read_chr('-');
        auto __month = __read_unsigned(2);
        __read_chr('-');
        auto __day = __read_unsigned(2);
        if (__is_failed(__err))
   break;
        __y = year(__year);
        __m = month(__month);
        __d = day(__day);
        if (!year_month_day(__y, __m, __d).ok())
   {
     __y = __yy = __iso_y = __iso_yy = __bad_y;
     __m = __bad_mon;
     __d = __bad_day;
     break;
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'g':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 0 && __val <= 99)
   {
     __iso_yy = year(__val);
     if (__century == -1)
       __century = 2000;
   }
        else
   __iso_yy = __iso_y = __y = __yy = __bad_y;
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'G':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      __iso_y = year(__read_unsigned(__num ? __num : 4));
    __parts |= _ChronoParts::_Year;
    break;

  case 'H':
  case 'I':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
# 3571 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
        __err |= ios_base::failbit;

      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__c == 'I' && __val >= 1 && __val <= 12)
   {
     __h12 = hours(__val);
     __h = __bad_h;
   }
        else if (__c == 'H' && __val >= 0 && __val <= 23)
   {
     __h = hours(__val);
     __h12 = __bad_h;
   }
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'j':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else if (_M_need == _ChronoParts::_TimeOfDay)
      {
        auto __val = __read_signed(__num ? __num : 3);
        if (!__is_failed(__err))
   {
     __h = days(__val);
     __parts |= _ChronoParts::_TimeOfDay;
   }
      }
    else
      {
        __dayofyear = __read_unsigned(__num ? __num : 3);


      }
    break;

  case 'm':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __m = month(__tm.tm_mon + 1);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 1 && __val <= 12)
   __m = month(__val);
        else
   __m = __bad_mon;
      }
    __parts |= _ChronoParts::_Month;
    break;

  case 'M':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __min = minutes(__tm.tm_min);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (0 <= __val && __val < 60)
   __min = minutes(__val);
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'p':
    if (__mod || __num)
      __err |= ios_base::failbit;
    else
      {


        const _CharT* __ampms[2];
        __tmpunct._M_am_pm(__ampms);
        int __n = 0, __which = 3;
        while (__which != 0)
   {
     auto __i = __is.peek();
     if (_Traits::eq_int_type(__i, _Traits::eof()))
       {
         __err |= ios_base::eofbit | ios_base::failbit;
         break;
       }
     __i = std::toupper(_Traits::to_char_type(__i), __loc);
     if (__which & 1)
       {
         if (__i != std::toupper(__ampms[0][__n], __loc))
    __which ^= 1;
         else if (__ampms[0][__n + 1] == _CharT())
    {
      __which = 1;
      (void) __is.get();
      break;
    }
       }
     if (__which & 2)
       {
         if (__i != std::toupper(__ampms[1][__n], __loc))
    __which ^= 2;
         else if (__ampms[1][__n + 1] == _CharT())
    {
      __which = 2;
      (void) __is.get();
      break;
    }
       }
     if (__which)
       (void) __is.get();
     ++__n;
   }
        if (__which == 0 || __which == 3)
   __err |= ios_base::failbit;
        else
   __ampm = __which;
      }
    break;

  case 'r':
    if (__mod || __num)
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   {
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'R':
  case 'T':
    if (__mod || __num) [[unlikely]]
      {
        __err |= ios_base::failbit;
        break;
      }
    else
      {
        auto __val = __read_unsigned(2);
        if (__val == -1 || __val > 23) [[unlikely]]
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
        if (!__read_chr(':')) [[unlikely]]
   break;
        __h = hours(__val);

        __val = __read_unsigned(2);
        if (__val == -1 || __val > 60) [[unlikely]]
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
        __min = minutes(__val);

        if (__c == 'R')
   {
     __parts |= _ChronoParts::_TimeOfDay;
     break;
   }
        else if (!__read_chr(':')) [[unlikely]]
   break;
      }
    [[fallthrough]];

  case 'S':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __s = seconds(__tm.tm_sec);
      }
    else if constexpr (_Duration::period::den == 1
           && !__is_floating)
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (0 <= __val && __val <= 59) [[likely]]
   __s = seconds(__val);
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    else
      {
        basic_stringstream<_CharT> __buf;
        auto __digit = _S_try_read_digit(__is, __err);
        if (__digit != -1)
   {
     __buf.put(_CharT('0') + __digit);
     __digit = _S_try_read_digit(__is, __err);
     if (__digit != -1)
       __buf.put(_CharT('0') + __digit);
   }

        auto __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit;
        else
   {
     _CharT __dp = '.';
     if (__loc != locale::classic())
       {
         auto& __np = use_facet<numpunct<_CharT>>(__loc);
         __dp = __np.decimal_point();
       }
     _CharT __c = _Traits::to_char_type(__i);
     if (__c == __dp)
       {
         (void) __is.get();
         __buf.put('.');
         int __prec
    = hh_mm_ss<_Duration>::fractional_width;
         do
    {
      __digit = _S_try_read_digit(__is, __err);
      if (__digit != -1)
        __buf.put(_CharT('0') + __digit);
      else
        break;
    }
         while (--__prec);
       }
   }

        if (!__is_failed(__err)) [[likely]]
   {
     long double __val{};

     string __str = std::move(__buf).str();
     auto __first = __str.data();
     auto __last = __first + __str.size();
     using enum chars_format;
     auto [ptr, ec] = std::from_chars(__first, __last,
          __val, fixed);
     if ((bool)ec || ptr != __last) [[unlikely]]
       __err |= ios_base::failbit;
     else



       {
         duration<long double> __fs(__val);
         if constexpr (__is_floating)
    __s = __fs;
         else
    __s = chrono::round<_Duration>(__fs);
       }
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'u':
  case 'w':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        if (__c == 'w')
   {
     struct tm __tm{};
     __tmget.get(__is, {}, __is, __err, &__tm,
          __fmt - 3, __fmt);
     if (!__is_failed(__err))
       __wday = weekday(__tm.tm_wday);
   }
        else
   __err |= ios_base::failbit;
      }
    else
      {
        const int __lo = __c == 'u' ? 1 : 0;
        const int __hi = __lo + 6;
        auto __val = __read_unsigned(__num ? __num : 1);
        if (__lo <= __val && __val <= __hi)
   __wday = weekday(__val);
        else
   {
     __wday = __bad_wday;
     break;
   }
      }
    __parts |= _ChronoParts::_Weekday;
    break;

  case 'U':
  case 'V':
  case 'W':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        if (__c == 'V') [[unlikely]]
   __err |= ios_base::failbit;
        else
   {


   }
      }
    else
      {
        const int __lo = __c == 'V' ? 1 : 0;
        const int __hi = 53;
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__lo <= __val && __val <= __hi)
   {
     switch (__c)
     {
       case 'U':
         __sunday_wk = __val;
         break;
       case 'V':
         __iso_wk = __val;
         break;
       case 'W':
         __monday_wk = __val;
         break;
     }
   }
        else
   __iso_wk = __sunday_wk = __monday_wk = -1;
      }

    break;

  case 'x':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __y = year(__tm.tm_year + 1900);
     __m = month(__tm.tm_mon + 1);
     __d = day(__tm.tm_mday);
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'X':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'y':
    if (__mod) [[unlikely]]
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   {
     int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
     __yy = year(__tm.tm_year - __cent);
     if (__century == -1)
       __century = __cent;
   }
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 0 && __val <= 99)
   {
     __yy = year(__val);
     if (__century == -1)
       __century = __val < 69 ? 2000 : 1900;
   }
        else
   __y = __yy = __iso_yy = __iso_y = __bad_y;
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'Y':
    if (__mod == 'O') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'E')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __y = year(__tm.tm_year);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 4);
        if (!__is_failed(__err))
   __y = year(__val);
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'z':
    if (__num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {



        auto __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   {
     __err |= ios_base::eofbit | ios_base::failbit;
     break;
   }
        _CharT __ic = _Traits::to_char_type(__i);
        const bool __neg = __ic == _CharT('-');
        if (__ic == _CharT('-') || __ic == _CharT('+'))
   (void) __is.get();

        int_least32_t __hh;
        if (__mod)
   {

     __hh = __read_unsigned(2);
   }
        else
   {

     __hh = 10 * _S_try_read_digit(__is, __err);
     __hh += _S_try_read_digit(__is, __err);
   }

        if (__is_failed(__err))
   break;

        __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   {
     __err |= ios_base::eofbit;
     __tz_offset = minutes(__hh * (__neg ? -60 : 60));
     break;
   }
        __ic = _Traits::to_char_type(__i);

        bool __read_mm = false;
        if (__mod)
   {
     if (__ic == ::std::__format::_Widen<_CharT>(":", L":")[0])
       {

         (void) __is.get();
         __read_mm = true;
       }
   }
        else if (_CharT('0') <= __ic && __ic <= _CharT('9'))
   {

     __read_mm = true;
   }

        int_least32_t __mm = 0;
        if (__read_mm)
   {
     __mm = 10 * _S_try_read_digit(__is, __err);
     __mm += _S_try_read_digit(__is, __err);
   }

        if (!__is_failed(__err))
   {
     auto __z = __hh * 60 + __mm;
     __tz_offset = minutes(__neg ? -__z : __z);
   }
      }
    break;

  case 'Z':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        basic_string_view<_CharT> __x = ::std::__format::_Widen<_CharT>("_/-+", L"_/-+");
        __tz_abbr.clear();
        while (true)
   {
     auto __i = __is.peek();
     if (!_Traits::eq_int_type(__i, _Traits::eof()))
       {
         _CharT __a = _Traits::to_char_type(__i);
         if (std::isalnum(__a, __loc)
        || __x.find(__a) != __x.npos)
    {
      __tz_abbr.push_back(__a);
      (void) __is.get();
      continue;
    }
       }
     else
       __err |= ios_base::eofbit;
     break;
   }
        if (__tz_abbr.empty())
   __err |= ios_base::failbit;
      }
    break;

  case 'n':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        _CharT __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit | ios_base::failbit;
        else if (std::isspace(_Traits::to_char_type(__i), __loc))
   (void) __is.get();
        else
   __err |= ios_base::failbit;
      }
    break;

  case 't':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        _CharT __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit;
        else if (std::isspace(_Traits::to_char_type(__i), __loc))
   (void) __is.get();
      }
    break;

  case '%':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      __read_chr('%');
    break;

  case 'O':
  case 'E':
    if (__mod || __num) [[unlikely]]
      {
        __err |= ios_base::failbit;
        break;
      }
    __mod = __c;
    continue;

  default:
    if (_CharT('1') <= __c && __c <= _CharT('9'))
      {
        if (!__mod) [[likely]]
   {

     auto __end = __fmt + _Traits::length(__fmt);
     auto [__v, __ptr]
       = __format::__parse_integer(__fmt - 1, __end);
     if (__ptr) [[likely]]
       {
         __num = __v;
         __fmt = __ptr;
         continue;
       }
   }
      }
    __err |= ios_base::failbit;
  }

       if (__is_failed(__err)) [[unlikely]]
  break;

       __is_flag = false;
       __num = 0;
       __mod = _CharT();
     }

   if (__century >= 0)
     {
       if (__yy != __bad_y && __y == __bad_y)
  __y = years(__century) + __yy;
       if (__iso_yy != __bad_y && __iso_y == __bad_y)
  __iso_y = years(__century) + __iso_yy;
     }

   bool __can_use_doy = false;
   bool __can_use_iso_wk = false;
   bool __can_use_sun_wk = false;
   bool __can_use_mon_wk = false;


   if (__y != __bad_y && __dayofyear >= 0)
     {
       __can_use_doy = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
     {
       __can_use_sun_wk = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
     {
       __can_use_mon_wk = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
     {

       __can_use_iso_wk = true;
       __parts |= _ChronoParts::_Date;
     }

   if (__is_failed(__err)) [[unlikely]]
     ;
   else if (__is_flag) [[unlikely]]
     __err |= ios_base::failbit;
   else if ((_M_need & __parts) == _M_need) [[likely]]
     {
# 4267 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/chrono_io.h" 3
       const bool __need_wday = _M_need & _ChronoParts::_Weekday;



       const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;

       if (__need_wday && __wday != __bad_wday)
  _M_wd = __wday;
       else if (_M_need & _ChronoParts::_Date)
  {


    const bool __need_ymd = !__need_wday && !__need_time;

    if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
       || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
       || (_M_need & _ChronoParts::_Day && __d == __bad_day))
      {



        if (__can_use_doy)
   {
     if ((0 < __dayofyear && __dayofyear <= 365)
    || (__dayofyear == 366 && __y.is_leap()))
       [[likely]]
       {
         _M_sys_days = sys_days(__y/January/1)
           + days(__dayofyear - 1);
         if (__need_ymd)
    _M_ymd = year_month_day(_M_sys_days);
       }
     else
       __err |= ios_base::failbit;
   }
        else if (__can_use_iso_wk)
   {


     if (__iso_wk == 53)
       {


         const sys_days __jan4(__iso_y/January/4);
         weekday __wd1(__jan4 - days(3));
         if (__wd1 != Thursday)
    if (__wd1 != Wednesday || !__iso_y.is_leap())
      __err |= ios_base::failbit;
       }

     if (!__is_failed(__err)) [[likely]]
       {

         sys_days __w(Thursday[1]/January/__iso_y);

         __w -= Thursday - Monday;
         __w += days(weeks(__iso_wk - 1));
         __w += __wday - Monday;
         _M_sys_days = __w;

         if (__need_ymd)
    _M_ymd = year_month_day(_M_sys_days);
       }
   }
        else if (__can_use_sun_wk)
   {

     sys_days __wk1(__y/January/Sunday[1]);
     _M_sys_days = __wk1 + weeks(__sunday_wk - 1)
     + days(__wday.c_encoding());
     _M_ymd = year_month_day(_M_sys_days);
     if (_M_ymd.year() != __y) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__can_use_mon_wk)
   {

     sys_days __wk1(__y/January/Monday[1]);
     _M_sys_days = __wk1 + weeks(__monday_wk - 1)
     + days(__wday.c_encoding() - 1);
     _M_ymd = year_month_day(_M_sys_days);
     if (_M_ymd.year() != __y) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else
   __err |= ios_base::failbit;
      }
    else
      {




        if (_M_need & _ChronoParts::_Year)
   {
     if (!__y.ok()) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__y == __bad_y)
   __y = 1972y;

        if (_M_need & _ChronoParts::_Month)
   {
     if (!__m.ok()) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__m == __bad_mon)
   __m = January;

        if (_M_need & _ChronoParts::_Day)
   {
     if (__d < day(1) || __d > (__y/__m/last).day())
       __err |= ios_base::failbit;
   }
        else if (__d == __bad_day)
   __d = 1d;

        if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
   {
     _M_ymd = __ymd;
     if (__need_wday || __need_time)
       _M_sys_days = sys_days(_M_ymd);
   }
        else [[unlikely]]
   __err |= ios_base::failbit;
      }

    if (__need_wday)
      _M_wd = weekday(_M_sys_days);
  }


       if (__need_time)
  {
    if (__h == __bad_h && __h12 != __bad_h)
      {
        if (__ampm == 1)
   __h = __h12 == hours(12) ? hours(0) : __h12;
        else if (__ampm == 2)
   __h = __h12 == hours(12) ? __h12 : __h12 + hours(12);
        else [[unlikely]]
   __err |= ios_base::failbit;
      }

    auto __t = _M_time.zero();
    bool __ok = false;

    if (__h != __bad_h)
      {
        __ok = true;
        __t += __h;
      }

    if (__min != __bad_min)
      {
        __ok = true;
        __t += __min;
      }

    if (__s != __bad_sec)
      {
        __ok = true;
        __t += __s;
        _M_is_leap_second = __s >= seconds(60);
      }

    if (__ok)
      _M_time = __t;
    else
      __err |= ios_base::failbit;
  }

       if (!__is_failed(__err)) [[likely]]
  {
    if (__offset && __tz_offset != __bad_min)
      *__offset = __tz_offset;
    if (__abbrev && !__tz_abbr.empty())
      *__abbrev = std::move(__tz_abbr);
  }
     }
   else
     __err |= ios_base::failbit;
 }
      if (__err)
 __is.setstate(__err);
      return __is;
    }




}


}
# 3379 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/chrono" 2 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/condition_variable" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/condition_variable" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 36 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 1 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 3
  class thread
  {
  public:

    using native_handle_type = __gthread_t;
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 3
    class id
    {
      native_handle_type _M_thread;

    public:
      id() noexcept : _M_thread() { }

      explicit
      id(native_handle_type __id) : _M_thread(__id) { }

    private:
      friend class thread;
      friend struct hash<id>;

      friend bool
      operator==(id __x, id __y) noexcept;


      friend strong_ordering
      operator<=>(id __x, id __y) noexcept;





      template<class _CharT, class _Traits>
 friend basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __out, id __id);





    };

  private:
    id _M_id;




    template<typename _Tp>
      using __not_same = __not_<is_same<__remove_cvref_t<_Tp>, thread>>;

  public:
    thread() noexcept = default;


  private:






    static void
    _M_thread_deps_never_run() {




    }

  public:
    template<typename _Callable, typename... _Args,
      typename = _Require<__not_same<_Callable>>>
      explicit
      thread(_Callable&& __f, _Args&&... __args)
      {
 static_assert( __is_invocable<typename decay<_Callable>::type,
          typename decay<_Args>::type...>::value,
   "std::thread arguments must be invocable after conversion to rvalues"
   );

 using _Wrapper = _Call_wrapper<_Callable, _Args...>;


 _M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
       std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
     _M_thread_deps_never_run);
      }


    ~thread()
    {
      if (joinable())
 std::__terminate();
    }

    thread(const thread&) = delete;

    thread(thread&& __t) noexcept
    { swap(__t); }

    thread& operator=(const thread&) = delete;

    thread& operator=(thread&& __t) noexcept
    {
      if (joinable())
 std::__terminate();
      swap(__t);
      return *this;
    }

    void
    swap(thread& __t) noexcept
    { std::swap(_M_id, __t._M_id); }

    bool
    joinable() const noexcept
    { return !(_M_id == id()); }

    void
    join();

    void
    detach();

    id
    get_id() const noexcept
    { return _M_id; }



    native_handle_type
    native_handle()
    { return _M_id._M_thread; }


    static unsigned int
    hardware_concurrency() noexcept;



  private:



    struct _State
    {
      virtual ~_State();
      virtual void _M_run() = 0;
    };
    using _State_ptr = unique_ptr<_State>;

  private:
    template<typename _Callable>
      struct _State_impl : public _State
      {
 _Callable _M_func;

 template<typename... _Args>
   _State_impl(_Args&&... __args)
   : _M_func(std::forward<_Args>(__args)...)
   { }

 void
 _M_run() { _M_func(); }
      };

    void
    _M_start_thread(_State_ptr, void (*)());
# 280 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 3
  private:

    template<typename _Tuple>
      struct _Invoker
      {
 template<typename... _Args>
   explicit
   _Invoker(_Args&&... __args)
   : _M_t(std::forward<_Args>(__args)...)
   { }

 _Tuple _M_t;

 template<typename>
   struct __result;
 template<typename _Fn, typename... _Args>
   struct __result<tuple<_Fn, _Args...>>
   : __invoke_result<_Fn, _Args...>
   { };

 template<size_t... _Ind>
   typename __result<_Tuple>::type
   _M_invoke(_Index_tuple<_Ind...>)
   { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); }

 typename __result<_Tuple>::type
 operator()()
 {
   using _Indices
     = typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type;
   return _M_invoke(_Indices());
 }
      };

  public:

    template<typename... _Tp>
      using _Call_wrapper = _Invoker<tuple<typename decay<_Tp>::type...>>;


  };
# 329 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/std_thread.h" 3
  inline void
  swap(thread& __x, thread& __y) noexcept
  { __x.swap(__y); }


  inline bool
  operator==(thread::id __x, thread::id __y) noexcept
  {




    return __x._M_thread == __y._M_thread;
  }





  template<>
    struct hash<thread::id>
    : public __hash_base<size_t, thread::id>
    {
      size_t
      operator()(const thread::id& __id) const noexcept
      { return std::_Hash_impl::hash(__id._M_thread); }
    };

  namespace this_thread
  {

    inline thread::id
    get_id() noexcept
    {



      return thread::id(pthread_self());



    }


    inline void
    yield() noexcept
    {

      __gthread_yield();

    }

  }




}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/semaphore" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/semaphore" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/semaphore_base.h" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/semaphore_base.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/this_thread_sleep.h" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/this_thread_sleep.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/this_thread_sleep.h" 3
  namespace this_thread
  {
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/this_thread_sleep.h" 3
    template<typename _Rep, typename _Period>
      inline void
      sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
 if (__rtime <= __rtime.zero())
   return;
 auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);

 struct ::timespec __ts =
   {
     static_cast<std::time_t>(__s.count()),
     static_cast<long>(__ns.count())
   };
 while (::nanosleep(&__ts, &__ts) == -1 && (*__errno_location ()) == 4)
   { }



      }


    template<typename _Clock, typename _Duration>
      inline void
      sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
      {

 static_assert(chrono::is_clock_v<_Clock>);

 auto __now = _Clock::now();
 if (_Clock::is_steady)
   {
     if (__now < __atime)
       sleep_for(__atime - __now);
     return;
   }
 while (__now < __atime)
   {
     sleep_for(__atime - __now);
     __now = _Clock::now();
   }
      }

  }




}
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 2 3



# 1 "/usr/include/sys/time.h" 1 3 4
# 34 "/usr/include/sys/time.h" 3 4
extern "C" {
# 52 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };
# 67 "/usr/include/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    void *__restrict __tz) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 86 "/usr/include/sys/time.h" 3 4
extern int settimeofday (const struct timeval *__tv,
    const struct timezone *__tz)
     noexcept (true);





extern int adjtime (const struct timeval *__delta,
      struct timeval *__olddelta) noexcept (true);
# 114 "/usr/include/sys/time.h" 3 4
enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };






typedef int __itimer_which_t;





extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) noexcept (true);




extern int setitimer (__itimer_which_t __which,
        const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) noexcept (true);




extern int utimes (const char *__file, const struct timeval __tvp[2])
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 189 "/usr/include/sys/time.h" 3 4
extern int lutimes (const char *__file, const struct timeval __tvp[2])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, const struct timeval __tvp[2]) noexcept (true);
# 214 "/usr/include/sys/time.h" 3 4
extern int futimesat (int __fd, const char *__file,
        const struct timeval __tvp[2]) noexcept (true);
# 258 "/usr/include/sys/time.h" 3 4
}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __detail
  {
    using __wait_clock_t = chrono::steady_clock;

    template<typename _Clock, typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<_Clock, _Dur>& __atime) noexcept
      {
 const typename _Clock::time_point __c_entry = _Clock::now();
 const __wait_clock_t::time_point __w_entry = __wait_clock_t::now();
 const auto __delta = __atime - __c_entry;
 using __w_dur = typename __wait_clock_t::duration;
 return __w_entry + chrono::ceil<__w_dur>(__delta);
      }

    template<typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<__wait_clock_t,
            _Dur>& __atime) noexcept
      {
 using __w_dur = typename __wait_clock_t::duration;
 return chrono::ceil<__w_dur>(__atime);
      }




    template<typename _Dur>
      bool
      __platform_wait_until_impl(const __platform_wait_t* __addr,
     __platform_wait_t __old,
     const chrono::time_point<__wait_clock_t, _Dur>&
          __atime) noexcept
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 struct timespec __rt =
 {
   static_cast<std::time_t>(__s.time_since_epoch().count()),
   static_cast<long>(__ns.count())
 };

 auto __e = syscall (202, __addr,
       static_cast<int>(__futex_wait_flags::
      __wait_bitset_private),
       __old, &__rt, nullptr,
       static_cast<int>(__futex_wait_flags::
      __bitset_match_any));

 if (__e)
   {
     if ((*__errno_location ()) == 110)
       return false;
     if ((*__errno_location ()) != 4 && (*__errno_location ()) != 11)
       __throw_system_error((*__errno_location ()));
   }
 return true;
      }


    template<typename _Clock, typename _Dur>
      bool
      __platform_wait_until(const __platform_wait_t* __addr, __platform_wait_t __old,
       const chrono::time_point<_Clock, _Dur>& __atime)
      {
 if constexpr (is_same_v<__wait_clock_t, _Clock>)
   {
     return __platform_wait_until_impl(__addr, __old, __atime);
   }
 else
   {
     if (!__platform_wait_until_impl(__addr, __old,
         __to_wait_clock(__atime)))
       {



  if (_Clock::now() < __atime)
    return true;
       }
     return false;
   }
      }
# 145 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 3
    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until_impl(__condvar& __cv, mutex& __mx,
        const chrono::time_point<_Clock, _Dur>& __atime)
      {
 static_assert(std::__is_one_of<_Clock, chrono::steady_clock,
            chrono::system_clock>::value);

 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };


 if constexpr (is_same_v<chrono::steady_clock, _Clock>)
   __cv.wait_until(__mx, 1, __ts);
 else

   __cv.wait_until(__mx, __ts);
 return _Clock::now() < __atime;
      }


    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until(__condvar& __cv, mutex& __mx,
   const chrono::time_point<_Clock, _Dur>& __atime)
      {

 if constexpr (is_same_v<_Clock, chrono::steady_clock>)
   return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
 else

 if constexpr (is_same_v<_Clock, chrono::system_clock>)
   return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
 else
   {
     if (__cond_wait_until_impl(__cv, __mx,
           __to_wait_clock(__atime)))
       {



  if (_Clock::now() < __atime)
    return true;
       }
     return false;
   }
      }


    struct __timed_waiter_pool : __waiter_pool_base
    {

      template<typename _Clock, typename _Dur>
 bool
 _M_do_wait_until(__platform_wait_t* __addr, __platform_wait_t __old,
    const chrono::time_point<_Clock, _Dur>& __atime)
 {

   return __platform_wait_until(__addr, __old, __atime);
# 221 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_timed_wait.h" 3
 }
    };

    struct __timed_backoff_spin_policy
    {
      __wait_clock_t::time_point _M_deadline;
      __wait_clock_t::time_point _M_t0;

      template<typename _Clock, typename _Dur>
 __timed_backoff_spin_policy(chrono::time_point<_Clock, _Dur>
          __deadline = _Clock::time_point::max(),
        chrono::time_point<_Clock, _Dur>
          __t0 = _Clock::now()) noexcept
   : _M_deadline(__to_wait_clock(__deadline))
   , _M_t0(__to_wait_clock(__t0))
 { }

      bool
      operator()() const noexcept
      {
 using namespace literals::chrono_literals;
 auto __now = __wait_clock_t::now();
 if (_M_deadline <= __now)
   return false;



 auto __elapsed = __now - _M_t0;
 if (__elapsed > 128ms)
   {
     this_thread::sleep_for(64ms);
   }
 else if (__elapsed > 64us)
   {
     this_thread::sleep_for(__elapsed / 2);
   }
 else if (__elapsed > 4us)
   {
     __thread_yield();
   }
 else
   return false;
 return true;
      }
    };

    template<typename _EntersWait>
      struct __timed_waiter : __waiter_base<__timed_waiter_pool>
      {
 using __base_type = __waiter_base<__timed_waiter_pool>;

 template<typename _Tp>
   __timed_waiter(const _Tp* __addr) noexcept
   : __base_type(__addr)
 {
   if constexpr (_EntersWait::value)
     _M_w._M_enter_wait();
 }

 ~__timed_waiter()
 {
   if constexpr (_EntersWait::value)
     _M_w._M_leave_wait();
 }


 template<typename _Tp, typename _ValFn,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until_v(_Tp __old, _ValFn __vfn,
        const chrono::time_point<_Clock, _Dur>&
        __atime) noexcept
   {
     __platform_wait_t __val;
     if (_M_do_spin(__old, std::move(__vfn), __val,
      __timed_backoff_spin_policy(__atime)))
       return true;
     return __base_type::_M_w._M_do_wait_until(__base_type::_M_addr, __val, __atime);
   }


 template<typename _Pred,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until(_Pred __pred, __platform_wait_t __val,
     const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
   {
     for (auto __now = _Clock::now(); __now < __atime;
    __now = _Clock::now())
       {
  if (__base_type::_M_w._M_do_wait_until(
        __base_type::_M_addr, __val, __atime)
      && __pred())
    return true;

  if (__base_type::_M_do_spin(__pred, __val,
          __timed_backoff_spin_policy(__atime, __now)))
    return true;
       }
     return false;
   }


 template<typename _Pred,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until(_Pred __pred,
      const chrono::time_point<_Clock, _Dur>&
        __atime) noexcept
   {
     __platform_wait_t __val;
     if (__base_type::_M_do_spin(__pred, __val,
     __timed_backoff_spin_policy(__atime)))
       return true;
     return _M_do_wait_until(__pred, __val, __atime);
   }

 template<typename _Tp, typename _ValFn,
   typename _Rep, typename _Period>
   bool
   _M_do_wait_for_v(_Tp __old, _ValFn __vfn,
      const chrono::duration<_Rep, _Period>&
        __rtime) noexcept
   {
     __platform_wait_t __val;
     if (_M_do_spin_v(__old, std::move(__vfn), __val))
       return true;

     if (!__rtime.count())
       return false;

     auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

     return __base_type::_M_w._M_do_wait_until(
       __base_type::_M_addr,
       __val,
       chrono::steady_clock::now() + __reltime);
   }

 template<typename _Pred,
   typename _Rep, typename _Period>
   bool
   _M_do_wait_for(_Pred __pred,
    const chrono::duration<_Rep, _Period>& __rtime) noexcept
   {
     __platform_wait_t __val;
     if (__base_type::_M_do_spin(__pred, __val))
       return true;

     if (!__rtime.count())
       return false;

     auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

     return _M_do_wait_until(__pred, __val,
        chrono::steady_clock::now() + __reltime);
   }
      };

    using __enters_timed_wait = __timed_waiter<std::true_type>;
    using __bare_timed_wait = __timed_waiter<std::false_type>;
  }


  template<typename _Tp, typename _ValFn,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
   const chrono::time_point<_Clock, _Dur>&
       __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until_v(__old, __vfn, __atime);
    }

  template<typename _Tp, typename _Pred,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until(const _Tp* __addr, _Pred __pred,
    const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

  template<typename _Pred,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_bare(const __detail::__platform_wait_t* __addr,
    _Pred __pred,
    const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

  template<typename _Tp, typename _ValFn,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
        const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for_v(__old, __vfn, __rtime);
    }

  template<typename _Tp, typename _Pred,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for(const _Tp* __addr, _Pred __pred,
        const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {

      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }

  template<typename _Pred,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_bare(const __detail::__platform_wait_t* __addr,
   _Pred __pred,
   const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }

}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/semaphore_base.h" 2 3






# 1 "/usr/include/semaphore.h" 1 3 4
# 28 "/usr/include/semaphore.h" 3 4
# 1 "/usr/include/bits/semaphore.h" 1 3 4
# 23 "/usr/include/bits/semaphore.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/semaphore.h" 2 3 4
# 35 "/usr/include/bits/semaphore.h" 3 4
typedef union
{
  char __size[32];
  long int __align;
} sem_t;
# 29 "/usr/include/semaphore.h" 2 3 4


extern "C" {



extern int sem_init (sem_t *__sem, int __pshared, unsigned int __value)
  noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_destroy (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern sem_t *sem_open (const char *__name, int __oflag, ...)
  noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_close (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_unlink (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int sem_wait (sem_t *__sem) __attribute__ ((__nonnull__ (1)));







extern int sem_timedwait (sem_t *__restrict __sem,
     const struct timespec *__restrict __abstime)
  __attribute__ ((__nonnull__ (1, 2)));
# 81 "/usr/include/semaphore.h" 3 4
extern int sem_clockwait (sem_t *__restrict __sem,
     clockid_t clock,
     const struct timespec *__restrict __abstime)
  __attribute__ ((__nonnull__ (1, 3)));
# 100 "/usr/include/semaphore.h" 3 4
extern int sem_trywait (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_post (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_getvalue (sem_t *__restrict __sem, int *__restrict __sval)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/semaphore_base.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{



  struct __platform_semaphore
  {
    using __clock_t = chrono::system_clock;

    static constexpr ptrdiff_t _S_max = (2147483647);




    explicit __platform_semaphore(ptrdiff_t __count) noexcept
    {
      sem_init(&_M_semaphore, 0, __count);
    }

    __platform_semaphore(const __platform_semaphore&) = delete;
    __platform_semaphore& operator=(const __platform_semaphore&) = delete;

    ~__platform_semaphore()
    { sem_destroy(&_M_semaphore); }

    inline __attribute__((__always_inline__)) void
    _M_acquire() noexcept
    {
      while (sem_wait(&_M_semaphore))
 if ((*__errno_location ()) != 4)
   std::__terminate();
    }

    inline __attribute__((__always_inline__)) bool
    _M_try_acquire() noexcept
    {
      while (sem_trywait(&_M_semaphore))
 {
   if ((*__errno_location ()) == 11)
     return false;
   else if ((*__errno_location ()) != 4)
     std::__terminate();

 }
      return true;
    }

    inline __attribute__((__always_inline__)) void
    _M_release(ptrdiff_t __update) noexcept
    {
      for(; __update != 0; --__update)
 if (sem_post(&_M_semaphore))
   std::__terminate();
    }

    bool
    _M_try_acquire_until_impl(const chrono::time_point<__clock_t>& __atime)
      noexcept
    {
      auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
      auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

      struct timespec __ts =
      {
 static_cast<std::time_t>(__s.time_since_epoch().count()),
 static_cast<long>(__ns.count())
      };

      while (sem_timedwait(&_M_semaphore, &__ts))
 {
   if ((*__errno_location ()) == 110)
     return false;
   else if ((*__errno_location ()) != 4)
     std::__terminate();
 }
      return true;
    }

    template<typename _Clock, typename _Duration>
      bool
      _M_try_acquire_until(const chrono::time_point<_Clock,
      _Duration>& __atime) noexcept
      {
 if constexpr (std::is_same_v<__clock_t, _Clock>)
   {
     using _Dur = __clock_t::duration;
     return _M_try_acquire_until_impl(chrono::ceil<_Dur>(__atime));
   }
 else
   {



     const typename _Clock::time_point __c_entry = _Clock::now();
     const auto __s_entry = __clock_t::now();
     const auto __delta = __atime - __c_entry;
     const auto __s_atime = __s_entry + __delta;
     if (_M_try_acquire_until_impl(__s_atime))
       return true;




     return (_Clock::now() < __atime);
   }
      }

    template<typename _Rep, typename _Period>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
 noexcept
      { return _M_try_acquire_until(__clock_t::now() + __rtime); }

  private:
    sem_t _M_semaphore;
  };



  struct __atomic_semaphore
  {
    static constexpr ptrdiff_t _S_max = __gnu_cxx::__int_traits<int>::__max;
    explicit __atomic_semaphore(__detail::__platform_wait_t __count) noexcept
      : _M_counter(__count)
    {
      do { if (std::__is_constant_evaluated() && !bool(__count >= 0 && __count <= _S_max)) std::__glibcxx_assert_fail(); } while (false);
    }

    __atomic_semaphore(const __atomic_semaphore&) = delete;
    __atomic_semaphore& operator=(const __atomic_semaphore&) = delete;

    static inline __attribute__((__always_inline__)) bool
    _S_do_try_acquire(__detail::__platform_wait_t* __counter) noexcept
    {
      auto __old = __atomic_impl::load(__counter, memory_order::acquire);
      if (__old == 0)
 return false;

      return __atomic_impl::compare_exchange_strong(__counter,
          __old, __old - 1,
          memory_order::acquire,
          memory_order::relaxed);
    }

    inline __attribute__((__always_inline__)) void
    _M_acquire() noexcept
    {
      auto const __pred =
 [this] { return _S_do_try_acquire(&this->_M_counter); };
      std::__atomic_wait_address_bare(&_M_counter, __pred);
    }

    bool
    _M_try_acquire() noexcept
    {
      auto const __pred =
 [this] { return _S_do_try_acquire(&this->_M_counter); };
      return std::__detail::__atomic_spin(__pred);
    }

    template<typename _Clock, typename _Duration>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_until(const chrono::time_point<_Clock,
      _Duration>& __atime) noexcept
      {
 auto const __pred =
   [this] { return _S_do_try_acquire(&this->_M_counter); };

 return __atomic_wait_address_until_bare(&_M_counter, __pred, __atime);
      }

    template<typename _Rep, typename _Period>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
 noexcept
      {
 auto const __pred =
   [this] { return _S_do_try_acquire(&this->_M_counter); };

 return __atomic_wait_address_for_bare(&_M_counter, __pred, __rtime);
      }

    inline __attribute__((__always_inline__)) void
    _M_release(ptrdiff_t __update) noexcept
    {
      if (0 < __atomic_impl::fetch_add(&_M_counter, __update, memory_order_release))
 return;
      if (__update > 1)
 __atomic_notify_address_bare(&_M_counter, true);
      else
 __atomic_notify_address_bare(&_M_counter, true);


    }

  private:
    alignas(__detail::__platform_wait_alignment)
    __detail::__platform_wait_t _M_counter;
  };





  using __semaphore_impl = __atomic_semaphore;





}
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/semaphore" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/semaphore" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  template<ptrdiff_t __least_max_value = __semaphore_impl::_S_max>
    class counting_semaphore
    {
      static_assert(__least_max_value >= 0);
      static_assert(__least_max_value <= __semaphore_impl::_S_max);

      __semaphore_impl _M_sem;

    public:
      explicit counting_semaphore(ptrdiff_t __desired) noexcept
 : _M_sem(__desired)
      { }

      ~counting_semaphore() = default;

      counting_semaphore(const counting_semaphore&) = delete;
      counting_semaphore& operator=(const counting_semaphore&) = delete;

      static constexpr ptrdiff_t
      max() noexcept
      { return __least_max_value; }

      void
      release(ptrdiff_t __update = 1) noexcept(noexcept(_M_sem._M_release(1)))
      { _M_sem._M_release(__update); }

      void
      acquire() noexcept(noexcept(_M_sem._M_acquire()))
      { _M_sem._M_acquire(); }

      bool
      try_acquire() noexcept(noexcept(_M_sem._M_try_acquire()))
      { return _M_sem._M_try_acquire(); }

      template<typename _Rep, typename _Period>
 bool
 try_acquire_for(const std::chrono::duration<_Rep, _Period>& __rtime)
 { return _M_sem._M_try_acquire_for(__rtime); }

      template<typename _Clock, typename _Dur>
 bool
 try_acquire_until(const std::chrono::time_point<_Clock, _Dur>& __atime)
 { return _M_sem._M_try_acquire_until(__atime); }
    };

  using binary_semaphore = std::counting_semaphore<1>;


}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  struct nostopstate_t { explicit nostopstate_t() = default; };
  inline constexpr nostopstate_t nostopstate{};

  class stop_source;


  class stop_token
  {
  public:
    stop_token() noexcept = default;

    stop_token(const stop_token&) noexcept = default;
    stop_token(stop_token&&) noexcept = default;

    ~stop_token() = default;

    stop_token&
    operator=(const stop_token&) noexcept = default;

    stop_token&
    operator=(stop_token&&) noexcept = default;

    [[nodiscard]]
    bool
    stop_possible() const noexcept
    {
      return static_cast<bool>(_M_state) && _M_state->_M_stop_possible();
    }

    [[nodiscard]]
    bool
    stop_requested() const noexcept
    {
      return static_cast<bool>(_M_state) && _M_state->_M_stop_requested();
    }

    void
    swap(stop_token& __rhs) noexcept
    { _M_state.swap(__rhs._M_state); }

    [[nodiscard]]
    friend bool
    operator==(const stop_token& __a, const stop_token& __b)
    { return __a._M_state == __b._M_state; }

    friend void
    swap(stop_token& __lhs, stop_token& __rhs) noexcept
    { __lhs.swap(__rhs); }

  private:
    friend class stop_source;
    template<typename _Callback>
      friend class stop_callback;

    static void
    _S_yield() noexcept
    {

      __builtin_ia32_pause();

      this_thread::yield();
    }
# 135 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 3
    struct _Stop_cb
    {
      using __cb_type = void(_Stop_cb*) noexcept;
      __cb_type* _M_callback;
      _Stop_cb* _M_prev = nullptr;
      _Stop_cb* _M_next = nullptr;
      bool* _M_destroyed = nullptr;
      binary_semaphore _M_done{0};

      [[__gnu__::__nonnull__]]
      explicit
      _Stop_cb(__cb_type* __cb)
      : _M_callback(__cb)
      { }

      void _M_run() noexcept { _M_callback(this); }
    };

    struct _Stop_state_t
    {
      using value_type = uint32_t;
      static constexpr value_type _S_stop_requested_bit = 1;
      static constexpr value_type _S_locked_bit = 2;
      static constexpr value_type _S_ssrc_counter_inc = 4;

      std::atomic<value_type> _M_owners{1};
      std::atomic<value_type> _M_value{_S_ssrc_counter_inc};
      _Stop_cb* _M_head = nullptr;
      std::thread::id _M_requester;

      _Stop_state_t() = default;

      bool
      _M_stop_possible() noexcept
      {


 return _M_value.load(memory_order::acquire) & ~_S_locked_bit;
      }

      bool
      _M_stop_requested() noexcept
      {
 return _M_value.load(memory_order::acquire) & _S_stop_requested_bit;
      }

      void
      _M_add_owner() noexcept
      {
 _M_owners.fetch_add(1, memory_order::relaxed);
      }

      void
      _M_release_ownership() noexcept
      {
 if (_M_owners.fetch_sub(1, memory_order::acq_rel) == 1)
   delete this;
      }

      void
      _M_add_ssrc() noexcept
      {
 _M_value.fetch_add(_S_ssrc_counter_inc, memory_order::relaxed);
      }

      void
      _M_sub_ssrc() noexcept
      {
 _M_value.fetch_sub(_S_ssrc_counter_inc, memory_order::release);
      }


      void
      _M_lock() noexcept
      {


 auto __old = _M_value.load(memory_order::relaxed);
 while (!_M_try_lock(__old, memory_order::relaxed))
   { }
      }


      void
      _M_unlock() noexcept
      {
 _M_value.fetch_sub(_S_locked_bit, memory_order::release);
      }

      bool
      _M_request_stop() noexcept
      {

 auto __old = _M_value.load(memory_order::acquire);
 do
   {
     if (__old & _S_stop_requested_bit)
       return false;
   }
 while (!_M_try_lock_and_stop(__old));

 _M_requester = this_thread::get_id();

 while (_M_head)
   {
     bool __last_cb;
     _Stop_cb* __cb = _M_head;
     _M_head = _M_head->_M_next;
     if (_M_head)
       {
  _M_head->_M_prev = nullptr;
  __last_cb = false;
       }
     else
       __last_cb = true;


     _M_unlock();

     bool __destroyed = false;
     __cb->_M_destroyed = &__destroyed;


     __cb->_M_run();

     if (!__destroyed)
       {
  __cb->_M_destroyed = nullptr;


  if (!__gnu_cxx::__is_single_threaded())
    __cb->_M_done.release();
       }


     if (__last_cb)
       return true;

     _M_lock();
   }

 _M_unlock();
 return true;
      }

      [[__gnu__::__nonnull__]]
      bool
      _M_register_callback(_Stop_cb* __cb) noexcept
      {
 auto __old = _M_value.load(memory_order::acquire);
 do
   {
     if (__old & _S_stop_requested_bit)
       {
  __cb->_M_run();
  return false;
       }

     if (__old < _S_ssrc_counter_inc)



       return false;
   }
 while (!_M_try_lock(__old));

        __cb->_M_next = _M_head;
        if (_M_head)
          {
            _M_head->_M_prev = __cb;
          }
        _M_head = __cb;
 _M_unlock();
        return true;
      }


      [[__gnu__::__nonnull__]]
      void
      _M_remove_callback(_Stop_cb* __cb)
      {
 _M_lock();

        if (__cb == _M_head)
          {
            _M_head = _M_head->_M_next;
            if (_M_head)
       _M_head->_M_prev = nullptr;
     _M_unlock();
     return;
          }
 else if (__cb->_M_prev)
          {
            __cb->_M_prev->_M_next = __cb->_M_next;
            if (__cb->_M_next)
       __cb->_M_next->_M_prev = __cb->_M_prev;
     _M_unlock();
     return;
          }

 _M_unlock();







 if (!(_M_requester == this_thread::get_id()))
   {

     __cb->_M_done.acquire();

     return;
   }

 if (__cb->_M_destroyed)
   *__cb->_M_destroyed = true;
      }





      bool
      _M_try_lock(value_type& __curval,
    memory_order __failure = memory_order::acquire) noexcept
      {
 return _M_do_try_lock(__curval, 0, memory_order::acquire, __failure);
      }







      bool
      _M_try_lock_and_stop(value_type& __curval) noexcept
      {
 return _M_do_try_lock(__curval, _S_stop_requested_bit,
         memory_order::acq_rel, memory_order::acquire);
      }

      bool
      _M_do_try_lock(value_type& __curval, value_type __newbits,
       memory_order __success, memory_order __failure) noexcept
      {
 if (__curval & _S_locked_bit)
   {
     _S_yield();
     __curval = _M_value.load(__failure);
     return false;
   }
 __newbits |= _S_locked_bit;
 return _M_value.compare_exchange_weak(__curval, __curval | __newbits,
           __success, __failure);
      }
    };

    struct _Stop_state_ref
    {
      _Stop_state_ref() = default;

      [[__gnu__::__access__(__none__, 2)]]
      explicit
      _Stop_state_ref(const stop_source&)
      : _M_ptr(new _Stop_state_t())
      { }

      _Stop_state_ref(const _Stop_state_ref& __other) noexcept
      : _M_ptr(__other._M_ptr)
      {
 if (_M_ptr)
   _M_ptr->_M_add_owner();
      }

      _Stop_state_ref(_Stop_state_ref&& __other) noexcept
      : _M_ptr(__other._M_ptr)
      {
 __other._M_ptr = nullptr;
      }

      _Stop_state_ref&
      operator=(const _Stop_state_ref& __other) noexcept
      {
 if (auto __ptr = __other._M_ptr; __ptr != _M_ptr)
   {
     if (__ptr)
       __ptr->_M_add_owner();
     if (_M_ptr)
       _M_ptr->_M_release_ownership();
     _M_ptr = __ptr;
   }
 return *this;
      }

      _Stop_state_ref&
      operator=(_Stop_state_ref&& __other) noexcept
      {
 _Stop_state_ref(std::move(__other)).swap(*this);
 return *this;
      }

      ~_Stop_state_ref()
      {
 if (_M_ptr)
   _M_ptr->_M_release_ownership();
      }

      void
      swap(_Stop_state_ref& __other) noexcept
      { std::swap(_M_ptr, __other._M_ptr); }

      explicit operator bool() const noexcept { return _M_ptr != nullptr; }

      _Stop_state_t* operator->() const noexcept { return _M_ptr; }


      friend bool
      operator==(const _Stop_state_ref&, const _Stop_state_ref&) = default;
# 468 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stop_token" 3
    private:
      _Stop_state_t* _M_ptr = nullptr;
    };

    _Stop_state_ref _M_state;

    explicit
    stop_token(const _Stop_state_ref& __state) noexcept
    : _M_state{__state}
    { }
  };


  class stop_source
  {
  public:
    stop_source() : _M_state(*this)
    { }

    explicit stop_source(std::nostopstate_t) noexcept
    { }

    stop_source(const stop_source& __other) noexcept
    : _M_state(__other._M_state)
    {
      if (_M_state)
 _M_state->_M_add_ssrc();
    }

    stop_source(stop_source&&) noexcept = default;

    stop_source&
    operator=(const stop_source& __other) noexcept
    {
      if (_M_state != __other._M_state)
 {
   stop_source __sink(std::move(*this));
   _M_state = __other._M_state;
   if (_M_state)
     _M_state->_M_add_ssrc();
 }
      return *this;
    }

    stop_source&
    operator=(stop_source&&) noexcept = default;

    ~stop_source()
    {
      if (_M_state)
 _M_state->_M_sub_ssrc();
    }

    [[nodiscard]]
    bool
    stop_possible() const noexcept
    {
      return static_cast<bool>(_M_state);
    }

    [[nodiscard]]
    bool
    stop_requested() const noexcept
    {
      return static_cast<bool>(_M_state) && _M_state->_M_stop_requested();
    }

    bool
    request_stop() const noexcept
    {
      if (stop_possible())
        return _M_state->_M_request_stop();
      return false;
    }

    [[nodiscard]]
    stop_token
    get_token() const noexcept
    {
      return stop_token{_M_state};
    }

    void
    swap(stop_source& __other) noexcept
    {
      _M_state.swap(__other._M_state);
    }

    [[nodiscard]]
    friend bool
    operator==(const stop_source& __a, const stop_source& __b) noexcept
    {
      return __a._M_state == __b._M_state;
    }

    friend void
    swap(stop_source& __lhs, stop_source& __rhs) noexcept
    {
      __lhs.swap(__rhs);
    }

  private:
    stop_token::_Stop_state_ref _M_state;
  };


  template<typename _Callback>
    class [[nodiscard]] stop_callback
    {
      static_assert(is_nothrow_destructible_v<_Callback>);
      static_assert(is_invocable_v<_Callback>);

    public:
      using callback_type = _Callback;

      template<typename _Cb,
               enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
        explicit
 stop_callback(const stop_token& __token, _Cb&& __cb)
        noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
 : _M_cb(std::forward<_Cb>(__cb))
        {
   if (auto __state = __token._M_state)
     {
       if (__state->_M_register_callback(&_M_cb))
  _M_state.swap(__state);
     }
        }

      template<typename _Cb,
               enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
        explicit
 stop_callback(stop_token&& __token, _Cb&& __cb)
        noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
 : _M_cb(std::forward<_Cb>(__cb))
 {
   if (auto& __state = __token._M_state)
     {
       if (__state->_M_register_callback(&_M_cb))
  _M_state.swap(__state);
     }
 }

      ~stop_callback()
      {
 if (_M_state)
   {
     _M_state->_M_remove_callback(&_M_cb);
   }
      }

      stop_callback(const stop_callback&) = delete;
      stop_callback& operator=(const stop_callback&) = delete;
      stop_callback(stop_callback&&) = delete;
      stop_callback& operator=(stop_callback&&) = delete;

    private:
      struct _Cb_impl : stop_token::_Stop_cb
      {
 template<typename _Cb>
   explicit
   _Cb_impl(_Cb&& __cb)
   : _Stop_cb(&_S_execute),
     _M_cb(std::forward<_Cb>(__cb))
   { }

 _Callback _M_cb;

 [[__gnu__::__nonnull__]]
 static void
 _S_execute(_Stop_cb* __that) noexcept
 {
   _Callback& __cb = static_cast<_Cb_impl*>(__that)->_M_cb;
   std::forward<_Callback>(__cb)();
 }
      };

      _Cb_impl _M_cb;
      stop_token::_Stop_state_ref _M_state;
    };

  template<typename _Callback>
    stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;


}
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/condition_variable" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{
# 69 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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;




    __condvar _M_cond;

  public:
    typedef __gthread_cond_t* 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);

    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)
      {

 static_assert(chrono::is_clock_v<_Clock>);

 using __s_dur = typename __clock_t::duration;
 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 +
   chrono::__detail::ceil<__s_dur>(__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;
 return wait_until(__lock,
     steady_clock::now() +
     chrono::__detail::ceil<__dur>(__rtime));
      }

    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;
 return wait_until(__lock,
     steady_clock::now() +
     chrono::__detail::ceil<__dur>(__rtime),
     std::move(__p));
      }

    native_handle_type
    native_handle()
    { return _M_cond.native_handle(); }

  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())
   };

 _M_cond.wait_until(*__lock.mutex(), 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())
   };

 _M_cond.wait_until(*__lock.mutex(), __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(); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 ~_Unlock() noexcept(false)
 {
   if (uncaught_exception())
     {
       try
       { _M_lock.lock(); }
       catch(const __cxxabiv1::__forced_unwind&)
       { throw; }
       catch(...)
       { }
     }
   else
     _M_lock.lock();
 }
#pragma GCC diagnostic pop

 _Unlock(const _Unlock&) = delete;
 _Unlock& operator=(const _Unlock&) = delete;

 _Lock& _M_lock;
      };

  public:
    condition_variable_any() : _M_mutex(std::make_shared<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)); }


    template <class _Lock, class _Predicate>
    bool wait(_Lock& __lock,
              stop_token __stoken,
              _Predicate __p)
    {
      if (__stoken.stop_requested())
        {
          return __p();
        }

      std::stop_callback __cb(__stoken, [this] { notify_all(); });
      shared_ptr<mutex> __mutex = _M_mutex;
      while (!__p())
        {
          unique_lock<mutex> __my_lock(*__mutex);
          if (__stoken.stop_requested())
            {
              return false;
            }


          _Unlock<_Lock> __unlock(__lock);
          unique_lock<mutex> __my_lock2(std::move(__my_lock));
          _M_cond.wait(__my_lock2);
        }
      return true;
    }

    template <class _Lock, class _Clock, class _Duration, class _Predicate>
    bool wait_until(_Lock& __lock,
                    stop_token __stoken,
                    const chrono::time_point<_Clock, _Duration>& __abs_time,
                    _Predicate __p)
    {
      if (__stoken.stop_requested())
        {
          return __p();
        }

      std::stop_callback __cb(__stoken, [this] { notify_all(); });
      shared_ptr<mutex> __mutex = _M_mutex;
      while (!__p())
        {
          bool __stop;
          {
            unique_lock<mutex> __my_lock(*__mutex);
            if (__stoken.stop_requested())
              {
                return false;
              }
            _Unlock<_Lock> __u(__lock);
            unique_lock<mutex> __my_lock2(std::move(__my_lock));
            const auto __status = _M_cond.wait_until(__my_lock2, __abs_time);
            __stop = (__status == std::cv_status::timeout) || __stoken.stop_requested();
          }
          if (__stop)
            {
              return __p();
            }
        }
      return true;
    }

    template <class _Lock, class _Rep, class _Period, class _Predicate>
    bool wait_for(_Lock& __lock,
                  stop_token __stoken,
                  const chrono::duration<_Rep, _Period>& __rel_time,
                  _Predicate __p)
    {
      auto __abst = std::chrono::steady_clock::now() + __rel_time;
      return wait_until(__lock,
                        std::move(__stoken),
                        __abst,
                        std::move(__p));
    }

  };

}



}
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/future" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/future" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_futex.h" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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);



    bool
    _M_futex_wait_until_steady(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::steady_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_until_steady(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_steady((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<std::chrono::system_clock, _Dur>& __atime)
    {
      auto __d = __atime.time_since_epoch();
      if (__d < __d.zero()) [[__unlikely__]]
 return false;
      auto __s = chrono::duration_cast<chrono::seconds>(__d);
      auto __ns = chrono::duration_cast<chrono::nanoseconds>(__d - __s);
      return _M_load_and_test_until(__assumed, __operand, __equal, __mo,
        true, __s, __ns);
    }

    template<typename _Dur>
    unsigned
    _M_load_and_test_until_impl(unsigned __assumed, unsigned __operand,
 bool __equal, memory_order __mo,
 const chrono::time_point<std::chrono::steady_clock, _Dur>& __atime)
    {
      auto __d = __atime.time_since_epoch();
      if (__d < __d.zero()) [[__unlikely__]]
 return false;
      auto __s = chrono::duration_cast<chrono::seconds>(__d);
      auto __ns = chrono::duration_cast<chrono::nanoseconds>(__d - __s);
      return _M_load_and_test_until_steady(__assumed, __operand, __equal, __mo,
   true, __s, __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)
      {
 using __dur = typename __clock_t::duration;
 return _M_load_when_equal_until(__val, __mo,
      __clock_t::now() + chrono::__detail::ceil<__dur>(__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)
      {
 typename _Clock::time_point __c_entry = _Clock::now();
 do {
   const __clock_t::time_point __s_entry = __clock_t::now();
   const auto __delta = __atime - __c_entry;
   const auto __s_atime = __s_entry +
       chrono::__detail::ceil<__clock_t::duration>(__delta);
   if (_M_load_when_equal_until(__val, __mo, __s_atime))
     return true;
   __c_entry = _Clock::now();
 } while (__c_entry < __atime);
 return false;
      }


    template<typename _Duration>
    inline __attribute__((__always_inline__)) bool
    _M_load_when_equal_until(unsigned __val, memory_order __mo,
 const chrono::time_point<std::chrono::system_clock, _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;
    }


    template<typename _Duration>
    inline __attribute__((__always_inline__)) bool
    _M_load_when_equal_until(unsigned __val, memory_order __mo,
 const chrono::time_point<std::chrono::steady_clock, _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);
    }
  };
# 364 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/atomic_futex.h" 3
}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/future" 2 3
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/future" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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 { };


  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  future_category() noexcept;


  [[__nodiscard__]]
  inline error_code
  make_error_code(future_errc __errc) noexcept
  { return error_code(static_cast<int>(__errc), future_category()); }


  [[__nodiscard__]]
  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
  };

  [[__nodiscard__]]
  constexpr launch operator&(launch __x, launch __y) noexcept
  {
    return static_cast<launch>(
 static_cast<int>(__x) & static_cast<int>(__y));
  }

  [[__nodiscard__]]
  constexpr launch operator|(launch __x, launch __y) noexcept
  {
    return static_cast<launch>(
 static_cast<int>(__x) | static_cast<int>(__y));
  }

  [[__nodiscard__]]
  constexpr launch operator^(launch __x, launch __y) noexcept
  {
    return static_cast<launch>(
 static_cast<int>(__x) ^ static_cast<int>(__y));
  }

  [[__nodiscard__]]
  constexpr launch operator~(launch __x) noexcept
  { return static_cast<launch>(~static_cast<int>(__x)); }

  constexpr
  inline launch& operator&=(launch& __x, launch __y) noexcept
  { return __x = __x & __y; }

  constexpr
  inline launch& operator|=(launch& __x, launch __y) noexcept
  { return __x = __x | __y; }

  constexpr
  inline launch& operator^=(launch& __x, launch __y) noexcept
  { 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>&)
      {
 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 (__rel > __rel.zero()
       && _M_status._M_load_when_equal_for(_Status::__ready,
        memory_order_acquire,
        __rel))
     {
# 393 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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)
 {

   static_assert(chrono::is_clock_v<_Clock>);



   if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
     return future_status::ready;

   if (_M_is_deferred_future())
     return future_status::deferred;

   if (_M_status._M_load_when_equal_until(_Status::__ready,
       memory_order_acquire,
       __abs))
     {



       _M_complete_async();

       return future_status::ready;
     }
   return future_status::timeout;
 }



      void
      _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
      {
 bool __did_set = false;


 call_once(_M_once, &_State_baseV2::_M_do_set, this,
    std::__addressof(__res), std::__addressof(__did_set));
 if (__did_set)

   _M_status._M_store_notify_all(_Status::__ready,
     memory_order_release);
 else if (!__ignore_failure)
   __throw_future_error(int(future_errc::promise_already_satisfied));
      }




      void
      _M_set_delayed_result(function<_Ptr_type()> __res,
       weak_ptr<_State_baseV2> __self)
      {
 bool __did_set = false;
 unique_ptr<_Make_ready> __mr{new _Make_ready};


 call_once(_M_once, &_State_baseV2::_M_do_set, this,
    std::__addressof(__res), std::__addressof(__did_set));
 if (!__did_set)
   __throw_future_error(int(future_errc::promise_already_satisfied));
 __mr->_M_shared_state = std::move(__self);
 __mr->_M_set();
 __mr.release();
      }


      void
      _M_break_promise(_Ptr_type __res)
      {
 if (static_cast<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 noexcept
   { 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 noexcept
   {
     _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>
 __attribute__((__always_inline__))
 static _Setter<_Res, _Arg&&>
 __setter(promise<_Res>* __prom, _Arg&& __arg) noexcept
 {
   return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) };
 }

      template<typename _Res>
 __attribute__((__always_inline__))
 static _Setter<_Res, __exception_ptr_tag>
 __setter(exception_ptr& __ex, promise<_Res>* __prom) noexcept
 {
   do { if (std::__is_constant_evaluated() && !bool(__ex != nullptr)) std::__glibcxx_assert_fail(); } while (false);
   return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex };
 }

      template<typename _Res>
 __attribute__((__always_inline__))
 static _Setter<_Res, void>
 __setter(promise<_Res>* __prom) noexcept
 {
   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>
      struct _Task_state_base;

    template<typename _Fn, typename _Alloc, typename _Signature>
      struct _Task_state;

    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 == nullptr))
   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>
    {


      static_assert(!is_array<_Res>{}, "result type must not be an array");
      static_assert(!is_function<_Res>{}, "result type must not be a function");
      static_assert(is_destructible<_Res>{},
      "result type must be destructible");

      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>
    {


      static_assert(!is_array<_Res>{}, "result type must not be an array");
      static_assert(!is_function<_Res>{}, "result type must not be a function");
      static_assert(is_destructible<_Res>{},
      "result type must be destructible");

      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
    {


      static_assert(!is_array<_Res>{}, "result type must not be an array");
      static_assert(!is_function<_Res>{}, "result type must not be a function");
      static_assert(is_destructible<_Res>{},
      "result type must be destructible");

      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 struct _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_state()._M_set_result(_State::__setter(this, __r)); }

      void
      set_value(_Res&& __r)
      { _M_state()._M_set_result(_State::__setter(this, std::move(__r))); }

      void
      set_exception(exception_ptr __p)
      { _M_state()._M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit(const _Res& __r)
      {
 _M_state()._M_set_delayed_result(_State::__setter(this, __r),
      _M_future);
      }

      void
      set_value_at_thread_exit(_Res&& __r)
      {
 _M_state()._M_set_delayed_result(
     _State::__setter(this, std::move(__r)), _M_future);
      }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_state()._M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }

    private:
      _State&
      _M_state()
      {
 __future_base::_State_base::_S_check(_M_future);
 return *_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 struct _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_state()._M_set_result(_State::__setter(this, __r)); }

      void
      set_exception(exception_ptr __p)
      { _M_state()._M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit(_Res& __r)
      {
 _M_state()._M_set_delayed_result(_State::__setter(this, __r),
      _M_future);
      }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_state()._M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }

    private:
      _State&
      _M_state()
      {
 __future_base::_State_base::_S_check(_M_future);
 return *_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 struct _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_state()._M_set_result(_State::__setter(this)); }

      void
      set_exception(exception_ptr __p)
      { _M_state()._M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit()
      { _M_state()._M_set_delayed_result(_State::__setter(this), _M_future); }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_state()._M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }

    private:
      _State&
      _M_state()
      {
 __future_base::_State_base::_S_check(_M_future);
 return *_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>>
    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)))
 {




   static_assert(is_invocable_r_v<_Res, decay_t<_Fn>&, _ArgTypes...>);

 }
# 1606 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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>
    packaged_task(_Res(*)(_ArgTypes...)) -> packaged_task<_Res(_ArgTypes...)>;

  template<typename _Fun, typename _Signature
      = __function_guide_t<_Fun, decltype(&_Fun::operator())>>
    packaged_task(_Fun) -> packaged_task<_Signature>;



  template<typename _Res, typename... _ArgTypes>
    inline void
    swap(packaged_task<_Res(_ArgTypes...)>& __x,
  packaged_task<_Res(_ArgTypes...)>& __y) noexcept
    { __x.swap(__y); }
# 1694 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/future" 3
  template<typename _BoundFn, typename _Res>
    class __future_base::_Deferred_state final
    : public __future_base::_State_base
    {
    public:
      template<typename... _Args>
 explicit
 _Deferred_state(_Args&&... __args)
 : _M_result(new _Result<_Res>()),
   _M_fn(std::forward<_Args>(__args)...)
 { }

    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;
# 1751 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/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:
      template<typename... _Args>
 explicit
 _Async_state_impl(_Args&&... __args)
 : _M_result(new _Result<_Res>()),
   _M_fn(std::forward<_Args>(__args)...)
 {
   _M_thread = std::thread{&_Async_state_impl::_M_run, this};
 }




      ~_Async_state_impl()
      {
 if (_M_thread.joinable())
   _M_thread.join();
      }

    private:
      void
      _M_run()
      {
 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;
   }
      }

      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
      _Ptr_type _M_result;
      _BoundFn _M_fn;
    };



  template<typename _Fn, typename... _Args>
    [[__nodiscard__]] future<__async_result_of<_Fn, _Args...>>
    async(launch __policy, _Fn&& __fn, _Args&&... __args)
    {
      using _Wr = std::thread::_Call_wrapper<_Fn, _Args...>;
      using _As = __future_base::_Async_state_impl<_Wr>;
      using _Ds = __future_base::_Deferred_state<_Wr>;

      std::shared_ptr<__future_base::_State_base> __state;
      if ((__policy & launch::async) == launch::async)
 {
   try
     {
       __state = std::make_shared<_As>(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 = std::make_shared<_Ds>(std::forward<_Fn>(__fn),
       std::forward<_Args>(__args)...);
 }
      return future<__async_result_of<_Fn, _Args...>>(std::move(__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)...);
    }






}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 1 3
# 52 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
  inline strong_ordering
  operator<=>(thread::id __x, thread::id __y) noexcept
  { return __x._M_thread <=> __y._M_thread; }
# 105 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
  template<class _CharT, class _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
    {

      using __output_type
 = __conditional_t<is_pointer<thread::native_handle_type>::value,
     const void*,
     thread::native_handle_type>;

      if (__id == thread::id())
 return __out << "thread::id of a non-executing thread";
      else
 return __out << static_cast<__output_type>(__id._M_thread);
    }
# 152 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
  class jthread
  {
  public:
    using id = thread::id;
    using native_handle_type = thread::native_handle_type;

    jthread() noexcept
    : _M_stop_source{nostopstate}
    { }

    template<typename _Callable, typename... _Args,
      typename = enable_if_t<!is_same_v<remove_cvref_t<_Callable>,
            jthread>>>
      explicit
      jthread(_Callable&& __f, _Args&&... __args)
      : _M_thread{_S_create(_M_stop_source, std::forward<_Callable>(__f),
       std::forward<_Args>(__args)...)}
      { }

    jthread(const jthread&) = delete;
    jthread(jthread&&) noexcept = default;

    ~jthread()
    {
      if (joinable())
        {
          request_stop();
          join();
        }
    }

    jthread&
    operator=(const jthread&) = delete;

    jthread&
    operator=(jthread&& __other) noexcept
    {
      std::jthread(std::move(__other)).swap(*this);
      return *this;
    }

    void
    swap(jthread& __other) noexcept
    {
      std::swap(_M_stop_source, __other._M_stop_source);
      std::swap(_M_thread, __other._M_thread);
    }

    [[nodiscard]] bool
    joinable() const noexcept
    {
      return _M_thread.joinable();
    }

    void
    join()
    {
      _M_thread.join();
    }

    void
    detach()
    {
      _M_thread.detach();
    }

    [[nodiscard]] id
    get_id() const noexcept
    {
      return _M_thread.get_id();
    }

    [[nodiscard]] native_handle_type
    native_handle()
    {
      return _M_thread.native_handle();
    }

    [[nodiscard]] static unsigned
    hardware_concurrency() noexcept
    {
      return thread::hardware_concurrency();
    }

    [[nodiscard]] stop_source
    get_stop_source() noexcept
    {
      return _M_stop_source;
    }

    [[nodiscard]] stop_token
    get_stop_token() const noexcept
    {
      return _M_stop_source.get_token();
    }

    bool request_stop() noexcept
    {
      return _M_stop_source.request_stop();
    }

    friend void swap(jthread& __lhs, jthread& __rhs) noexcept
    {
      __lhs.swap(__rhs);
    }

  private:
    template<typename _Callable, typename... _Args>
      static thread
      _S_create(stop_source& __ssrc, _Callable&& __f, _Args&&... __args)
      {





 if constexpr(is_invocable_v<decay_t<_Callable>, stop_token,
        decay_t<_Args>...>)
   return thread{std::forward<_Callable>(__f), __ssrc.get_token(),
   std::forward<_Args>(__args)...};
 else
   {
     static_assert(is_invocable_v<decay_t<_Callable>,
      decay_t<_Args>...>,
     "std::jthread arguments must be invocable after"
     " conversion to rvalues");
     return thread{std::forward<_Callable>(__f),
     std::forward<_Args>(__args)...};
   }
      }
# 294 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
    stop_source _M_stop_source;
    thread _M_thread;
  };
# 377 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/thread" 3
}
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 2 3








template <typename _Tp>
using G4Future = std::future<_Tp>;
template <typename _Tp>
using G4SharedFuture = std::shared_future<_Tp>;
template <typename _Tp>
using G4Promise = std::promise<_Tp>;
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
using G4Mutex = std::mutex;
using G4RecursiveMutex = std::recursive_mutex;
# 95 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
namespace G4ThisThread
{
  using namespace std::this_thread;
}



template <typename _Tp>
using G4Promise = std::promise<_Tp>;
template <typename _Tp>
using G4Future = std::future<_Tp>;
template <typename _Tp>
using G4SharedFuture = std::shared_future<_Tp>;


using G4ThreadFunReturnType = void*;
using G4ThreadFunArgType = void*;
using thread_lock =
  G4int (*)(G4Mutex*);
using thread_unlock =
  G4int (*)(G4Mutex*);







template <typename _Tp>
G4Mutex& G4TypeMutex()
{
  static G4Mutex _mutex;
  return _mutex;
}
# 137 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
template <typename _Tp>
G4RecursiveMutex& G4TypeRecursiveMutex()
{
  static G4RecursiveMutex _mutex;
  return _mutex;
}
# 199 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
class G4DummyThread
{
 public:
  using native_handle_type = G4int;
  using id = std::thread::id;

 public:

  G4DummyThread() {}

  template <typename _Func, typename... _Args>
  G4DummyThread(_Func func, _Args&&... _args)
  {
    func(std::forward<_Args>(_args)...);
  }

 public:
  native_handle_type native_handle() const { return native_handle_type(); }
  G4bool joinable() const { return true; }
  id get_id() const noexcept { return std::this_thread::get_id(); }
  void swap(G4DummyThread&) {}
  void join() {}
  void detach() {}

 public:
  static unsigned int hardware_concurrency() noexcept
  {
    return std::thread::hardware_concurrency();
  }
};


using G4Thread = G4DummyThread;
using G4NativeThread = G4DummyThread::native_handle_type;
# 247 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
using G4Pid_t = G4int;



template <typename _Worker, typename _Func, typename... _Args>
void G4THREADCREATE(_Worker*& worker, _Func func, _Args... args)
{
  *worker = G4Thread(func, std::forward<_Args>(args)...);
}

using G4Condition = G4int;
# 270 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Threading.hh" 3
using G4ThreadId = G4Thread::id;



namespace G4Threading
{
  enum
  {
    SEQUENTIAL_ID = -2,
    MASTER_ID = -1,
    WORKER_ID = 0,
    GENERICTHREAD_ID = -1000
  };

  G4Pid_t G4GetPidId();
  G4int G4GetNumberOfCores();
  G4int G4GetThreadId();
  G4bool IsWorkerThread();
  G4bool IsMasterThread();
  void G4SetThreadId(G4int aNewValue);
  G4bool G4SetPinAffinity(G4int idx, G4NativeThread& at);
  void SetMultithreadedApplication(G4bool value);
  G4bool IsMultithreadedApplication();
  G4int WorkerThreadLeavesPool();
  G4int WorkerThreadJoinsPool();
  G4int GetNumberOfRunningWorkerThreads();
}
# 263 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 2 3
# 272 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
template <typename _Mutex_t>
class G4TemplateAutoLock : public std::unique_lock<_Mutex_t>
{
 public:



  using unique_lock_t = std::unique_lock<_Mutex_t>;
  using this_type = G4TemplateAutoLock<_Mutex_t>;
  using mutex_type = typename unique_lock_t::mutex_type;

 public:
# 292 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  G4TemplateAutoLock(mutex_type& _mutex)
    : unique_lock_t(_mutex, std::defer_lock)
  {

    _lock_deferred();
  }





  template <typename Rep, typename Period>
  G4TemplateAutoLock(
    mutex_type& _mutex,
    const std::chrono::duration<Rep, Period>& _timeout_duration)
    : unique_lock_t(_mutex, std::defer_lock)
  {

    _lock_deferred(_timeout_duration);
  }





  template <typename Clock, typename Duration>
  G4TemplateAutoLock(
    mutex_type& _mutex,
    const std::chrono::time_point<Clock, Duration>& _timeout_time)
    : unique_lock_t(_mutex, std::defer_lock)
  {

    _lock_deferred(_timeout_time);
  }


  G4TemplateAutoLock(mutex_type& _mutex, std::defer_lock_t _lock) noexcept
    : unique_lock_t(_mutex, _lock)
  {}
# 349 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  G4TemplateAutoLock(mutex_type& _mutex, std::try_to_lock_t)
    : unique_lock_t(_mutex, std::defer_lock)
  {}


  G4TemplateAutoLock(mutex_type& _mutex, std::adopt_lock_t)
    : unique_lock_t(_mutex, std::defer_lock)
  {}



 public:



  G4TemplateAutoLock(mutex_type* _mutex)
    : unique_lock_t(*_mutex, std::defer_lock)
  {

    _lock_deferred();
  }

  G4TemplateAutoLock(mutex_type* _mutex, std::defer_lock_t _lock) noexcept
    : unique_lock_t(*_mutex, _lock)
  {}
# 387 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  G4TemplateAutoLock(mutex_type* _mutex, std::try_to_lock_t)
    : unique_lock_t(*_mutex, std::defer_lock)
  {}

  G4TemplateAutoLock(mutex_type* _mutex, std::adopt_lock_t)
    : unique_lock_t(*_mutex, std::defer_lock)
  {}



 public:
# 410 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  void lock() {}
  void unlock() {}
  bool try_lock() { return true; }

  template <typename Rep, typename Period>
  bool try_lock_for(const std::chrono::duration<Rep, Period>&)
  {
    return true;
  }

  template <typename Clock, typename Duration>
  bool try_lock_until(const std::chrono::time_point<Clock, Duration>&)
  {
    return true;
  }

  void swap(this_type& other) noexcept { std::swap(*this, other); }
  bool owns_lock() const noexcept { return false; }
# 437 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
 private:





  template <typename _Tp = _Mutex_t,
            typename std::enable_if<(std::is_same<_Tp, G4Mutex>::value), int>::type = 0>
  std::string GetTypeString()
  {
    return "G4AutoLock<G4Mutex>";
  }

  template <typename _Tp = _Mutex_t,
            typename std::enable_if<(std::is_same<_Tp, G4RecursiveMutex>::value), int>::type = 0>
  std::string GetTypeString()
  {
    return "G4AutoLock<G4RecursiveMutex>";
  }

  template <typename _Tp = _Mutex_t,
            typename std::enable_if<(!(std::is_same<_Tp, G4Mutex>::value) && !(std::is_same<_Tp, G4RecursiveMutex>::value)), int>::type = 0>
  std::string GetTypeString()
  {
    return "G4AutoLock<UNKNOWN_MUTEX>";
  }







  template <typename _Tp>
  void suppress_unused_variable(const _Tp&)
  {}
# 494 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  inline void _lock_deferred()
  {
# 505 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
  }






  template <typename Rep, typename Period>
  void _lock_deferred(
    const std::chrono::duration<Rep, Period>& _timeout_duration)
  {
# 525 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
    suppress_unused_variable(_timeout_duration);

  }






  template <typename Clock, typename Duration>
  void _lock_deferred(
    const std::chrono::time_point<Clock, Duration>& _timeout_time)
  {
# 547 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
    suppress_unused_variable(_timeout_time);

  }




  void PrintLockErrorMessage(std::system_error& e)
  {

    using std::cout;
    using std::endl;
# 569 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
    suppress_unused_variable(e);

  }
};
# 582 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AutoLock.hh" 3
using G4AutoLock = G4TemplateAutoLock<G4Mutex>;
using G4RecursiveAutoLock = G4TemplateAutoLock<G4RecursiveMutex>;



template <typename _Tp>
using G4TAutoLock = G4TemplateAutoLock<_Tp>;
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4GeomSplitter.hh" 2 3

template <class T>
class G4GeomSplitter
{
  public:

    G4GeomSplitter()
      : sharedOffset(nullptr)
    {
      ; ;;
    }

    T* Reallocate(G4int size)
    {
       totalspace = size;
       return (T *) std::realloc(offset, totalspace * sizeof(T));
    }

    G4int CreateSubInstance()


    {
      G4AutoLock l(&mutex);
      ++totalobj;
      if (totalobj > totalspace)
      {
        offset = Reallocate(totalspace+512);
        if (offset == nullptr)
        {
           G4Exception("G4GeomSPlitter::CreateSubInstance()",
                       "OutOfMemory", FatalException, "Cannot malloc space!");
        }
        sharedOffset = offset;
      }
      return (totalobj - 1);
    }

    void CopyMasterContents()
    {
      G4AutoLock l(&mutex);
      std::memcpy(offset, sharedOffset, totalspace * sizeof(T));
    }

    void SlaveCopySubInstanceArray()


    {
      G4AutoLock l(&mutex);
      if (offset != nullptr) { return; }
      offset = Reallocate(totalspace);
      if (offset == nullptr)
      {
        G4Exception("G4GeomSplitter::SlaveCopySubInstanceArray()",
                    "OutOfMemory", FatalException, "Cannot malloc space!");
      }
      l.unlock();
      CopyMasterContents();
    }

    void SlaveInitializeSubInstance()



    {
      G4AutoLock l(&mutex);
      if (offset != nullptr) { return; }
      offset = Reallocate(totalspace);

      if (offset == nullptr)
      {
        G4Exception("G4GeomSplitter::SlaveInitializeSubInstance()",
                    "OutOfMemory", FatalException, "Cannot malloc space!");
      }

      for (G4int i=0 ; i<totalspace; ++i)
      {
        offset[i].initialize();
      }
    }

    void SlaveReCopySubInstanceArray()




    {
      if (offset == nullptr)
      {
        SlaveInitializeSubInstance();
        G4Exception("G4GeomSPlitter::SlaveReCopySubInstance()",
                    "MissingInitialisation", JustWarning,
                    "Must be called after Initialisation or first Copy.");
      }
      CopyMasterContents();
    }

    void FreeSlave()

    {
      if (offset == nullptr) { return; }
      std::free( offset );
      offset = nullptr;
    }



    T* GetOffset() { return offset; }

    void UseWorkArea( T* newOffset )

    {
      if( (offset!=nullptr) && (offset!=newOffset) )
      {
         G4Exception("G4GeomSplitter::UseWorkspace()",
                     "TwoWorkspaces", FatalException,
                     "Thread already has workspace - cannot use another.");
      }
      offset= newOffset;
    }

    T* FreeWorkArea()


    {
      T* offsetRet = offset;
      offset = nullptr;
      return offsetRet;
    }

  public:

               static T* offset;

  private:

    G4int totalobj{0};
    G4int totalspace{0};
    T* sharedOffset;
    G4Mutex mutex;
};

template <typename T> T* G4GeomSplitter<T>::offset = nullptr;
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 2 3

class G4LogicalVolume;
class G4VPVParameterisation;

class G4PVData
{




  public:

    G4PVData() = default;

    void initialize()
    {
      frot = nullptr;
      tx = 0.; ty = 0.; tz = 0.;
    }

    G4RotationMatrix* frot = nullptr;
    G4double tx = 0., ty = 0., tz = 0.;
};

using G4PVManager = G4GeomSplitter<G4PVData>;


class G4VPhysicalVolume
{
  public:

    G4VPhysicalVolume(G4RotationMatrix* pRot,
                const G4ThreeVector& tlate,
                const G4String& pName,
                      G4LogicalVolume* pLogical,
                      G4VPhysicalVolume* pMother);
# 100 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 3
    virtual ~G4VPhysicalVolume();


    G4VPhysicalVolume(const G4VPhysicalVolume&) = delete;
    G4VPhysicalVolume& operator=(const G4VPhysicalVolume&) = delete;


    inline G4bool operator == (const G4VPhysicalVolume& p) const;
# 117 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 3
    G4RotationMatrix* GetObjectRotation() const;
    G4RotationMatrix GetObjectRotationValue() const;
    G4ThreeVector GetObjectTranslation() const;

    const G4RotationMatrix* GetFrameRotation() const;
    G4ThreeVector GetFrameTranslation() const;





    const G4ThreeVector GetTranslation() const;
    const G4RotationMatrix* GetRotation() const;





    void SetTranslation(const G4ThreeVector& v);
    G4RotationMatrix* GetRotation();
    void SetRotation(G4RotationMatrix*);




    inline G4LogicalVolume* GetLogicalVolume() const;

    inline void SetLogicalVolume(G4LogicalVolume* pLogical);


    inline G4LogicalVolume* GetMotherLogical() const;

    inline void SetMotherLogical(G4LogicalVolume* pMother);


    inline const G4String& GetName() const;

    void SetName(const G4String& pName);


    virtual G4int GetMultiplicity() const;





    virtual EVolume VolumeType() const = 0;

    virtual G4bool IsMany() const = 0;

    virtual G4int GetCopyNo() const = 0;

    virtual void SetCopyNo(G4int CopyNo) = 0;

    virtual G4bool IsReplicated() const = 0;


    virtual G4bool IsParameterised() const = 0;


    virtual G4VPVParameterisation* GetParameterisation() const = 0;


    virtual void GetReplicationData(EAxis& axis,
                                    G4int& nReplicas,
                                    G4double& width,
                                    G4double& offset,
                                    G4bool& consuming) const = 0;

    virtual G4bool IsRegularStructure() const = 0;

    virtual G4int GetRegularStructureId() const = 0;




    virtual G4bool CheckOverlaps(G4int res=1000, G4double tol=0.,
                                 G4bool verbose=true, G4int errMax=1);






  public:

    G4VPhysicalVolume(__void__&);




    inline G4int GetInstanceID() const;


    static const G4PVManager& GetSubInstanceManager();


    static void Clean();


    inline EVolume DeduceVolumeType() const;



  protected:

    void InitialiseWorker(G4VPhysicalVolume* pMasterObject,
                          G4RotationMatrix* pRot, const G4ThreeVector& tlate);



    void TerminateWorker(G4VPhysicalVolume* pMasterObject);



  protected:

    G4int instanceID;


               static G4PVManager subInstanceManager;


  private:

    G4LogicalVolume* flogical = nullptr;


    G4String fname;
    G4LogicalVolume* flmother = nullptr;

    G4PVData* pvdata = nullptr;
};
# 270 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.icc" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.icc" 3
inline
G4bool G4VPhysicalVolume::operator == (const G4VPhysicalVolume& right) const
{
  return this==&right;
}

inline
G4int G4VPhysicalVolume::GetInstanceID() const
{
  return instanceID;
}

inline
G4LogicalVolume* G4VPhysicalVolume::GetLogicalVolume() const
{
  return flogical;
}

inline
void G4VPhysicalVolume::SetLogicalVolume(G4LogicalVolume* pLogical)
{
  flogical = pLogical;
}

inline
G4LogicalVolume* G4VPhysicalVolume::GetMotherLogical() const
{
  return flmother;
}

inline
void G4VPhysicalVolume::SetMotherLogical(G4LogicalVolume* pMother)
{
  flmother = pMother;
}

inline
const G4String& G4VPhysicalVolume::GetName() const
{
  return fname;
}

inline
EVolume G4VPhysicalVolume::DeduceVolumeType() const
{
  EVolume type;
  EAxis axis;
  G4int nReplicas;
  G4double width,offset;
  G4bool consuming;
  if ( IsReplicated() )
  {
    GetReplicationData(axis,nReplicas,width,offset,consuming);
    type = (consuming) ? kReplica : kParameterised;
  }
  else
  {
    type = kNormal;
  }
  return type;
}
# 271 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VPhysicalVolume.hh" 2 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SteppingControl.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SteppingControl.hh" 3
enum G4SteppingControl
{
  NormalCondition,
  AvoidHitInvocation,

  Debug
};
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepStatus.hh" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepStatus.hh" 3
enum G4StepStatus
{
  fWorldBoundary,

  fGeomBoundary,

  fAtRestDoItProc,

  fAlongStepDoItProc,

  fPostStepDoItProc,

  fUserDefinedLimit,

  fExclusivelyForcedProc,

  fUndefined

};
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHandle.hh" 1 3
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHandle.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VTouchable.hh" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VTouchable.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.hh" 1 3
# 95 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 3
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.hh" 1 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Transform3D.hh" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Transform3D.hh" 3
using G4Transform3D = HepGeom::Transform3D;

using G4Rotate3D = HepGeom::Rotate3D;
using G4RotateX3D = HepGeom::RotateX3D;
using G4RotateY3D = HepGeom::RotateY3D;
using G4RotateZ3D = HepGeom::RotateZ3D;

using G4Translate3D = HepGeom::Translate3D;
using G4TranslateX3D = HepGeom::TranslateX3D;
using G4TranslateY3D = HepGeom::TranslateY3D;
using G4TranslateZ3D = HepGeom::TranslateZ3D;

using G4Reflect3D = HepGeom::Reflect3D;
using G4ReflectX3D = HepGeom::ReflectX3D;
using G4ReflectY3D = HepGeom::ReflectY3D;
using G4ReflectZ3D = HepGeom::ReflectZ3D;

using G4Scale3D = HepGeom::Scale3D;
using G4ScaleX3D = HepGeom::ScaleX3D;
using G4ScaleY3D = HepGeom::ScaleY3D;
using G4ScaleZ3D = HepGeom::ScaleZ3D;
# 68 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.hh" 2 3

class G4AffineTransform
{
  public:

    inline G4AffineTransform();

  public:

    inline G4AffineTransform(const G4ThreeVector& tlate);


    inline G4AffineTransform(const G4RotationMatrix& rot);


    inline G4AffineTransform(const G4RotationMatrix& rot,
                             const G4ThreeVector& tlate);


    inline G4AffineTransform(const G4RotationMatrix* rot,
                             const G4ThreeVector& tlate);


    inline G4AffineTransform(const G4AffineTransform& rhs) = default;
    inline G4AffineTransform(G4AffineTransform&& rhs) = default;


    inline G4AffineTransform& operator=(const G4AffineTransform& rhs);
    inline G4AffineTransform& operator=(G4AffineTransform&& rhs) = default;


    inline ~G4AffineTransform() = default;


    inline G4AffineTransform operator * (const G4AffineTransform& tf) const;




    inline G4AffineTransform& operator *= (const G4AffineTransform& tf);



    inline G4AffineTransform& Product(const G4AffineTransform& tf1,
                                      const G4AffineTransform& tf2);





    inline G4AffineTransform& InverseProduct(const G4AffineTransform& tf1,
                                             const G4AffineTransform& tf2);


    inline G4ThreeVector TransformPoint(const G4ThreeVector& vec) const;


    inline G4ThreeVector InverseTransformPoint(const G4ThreeVector& vec) const;


    inline G4ThreeVector TransformAxis(const G4ThreeVector& axis) const;


    inline G4ThreeVector InverseTransformAxis(const G4ThreeVector& axis) const;


    inline void ApplyPointTransform(G4ThreeVector& vec) const;


    inline void ApplyAxisTransform(G4ThreeVector& axis) const;


    inline G4AffineTransform Inverse() const;


    inline G4AffineTransform& Invert();


    inline G4AffineTransform& operator +=(const G4ThreeVector& tlate);
    inline G4AffineTransform& operator -=(const G4ThreeVector& tlate);



    inline G4bool operator == (const G4AffineTransform& tf) const;
    inline G4bool operator != (const G4AffineTransform& tf) const;

    inline G4double operator [] (const G4int n) const;

    inline G4bool IsRotated() const;


    inline G4bool IsTranslated() const;


    inline G4RotationMatrix NetRotation() const;

    inline G4RotationMatrix InverseNetRotation() const;

    inline G4ThreeVector NetTranslation() const;

    inline G4ThreeVector InverseNetTranslation() const;

    inline void SetNetRotation(const G4RotationMatrix& rot);

    inline void SetNetTranslation(const G4ThreeVector& tlate);

    inline operator G4Transform3D () const;


  private:

    inline G4AffineTransform(
                  const G4double prxx, const G4double prxy, const G4double prxz,
                  const G4double pryx, const G4double pryy, const G4double pryz,
                  const G4double przx, const G4double przy, const G4double przz,
                  const G4double ptx, const G4double pty, const G4double ptz);

    G4double rxx,rxy,rxz;
    G4double ryx,ryy,ryz;
    G4double rzx,rzy,rzz;
    G4double tx,ty,tz;
};

std::ostream& operator << (std::ostream& os, const G4AffineTransform& transf);

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.icc" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.icc" 3
inline G4AffineTransform::G4AffineTransform()
 : rxx(1),rxy(0),rxz(0),
   ryx(0),ryy(1),ryz(0),
   rzx(0),rzy(0),rzz(1),
   tx(0),ty(0),tz(0)
{}

inline G4AffineTransform::G4AffineTransform(const G4ThreeVector& tlate)
 : rxx(1),rxy(0),rxz(0),
   ryx(0),ryy(1),ryz(0),
   rzx(0),rzy(0),rzz(1),
   tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
{}

inline G4AffineTransform::G4AffineTransform(const G4RotationMatrix& rot)
 : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
   ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
   rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
   tx(0),ty(0),tz(0)
{}

inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix& rot,
                                             const G4ThreeVector& tlate )
 : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
   ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
   rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
   tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
{}

inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix* rot,
                                             const G4ThreeVector& tlate )
 : tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
{
  if (rot != nullptr)
  {
    rxx=rot->xx();rxy=rot->xy();rxz=rot->xz();
    ryx=rot->yx();ryy=rot->yy();ryz=rot->yz();
    rzx=rot->zx();rzy=rot->zy();rzz=rot->zz();
  }
  else
  {
    rxx=1; rxy=0; rxz=0;
    ryx=0; ryy=1; ryz=0;
    rzx=0; rzy=0; rzz=1;
  }
}

inline
G4AffineTransform::
G4AffineTransform( const G4double prxx,const G4double prxy,const G4double prxz,
                   const G4double pryx,const G4double pryy,const G4double pryz,
                   const G4double przx,const G4double przy,const G4double przz,
                   const G4double ptx,const G4double pty,const G4double ptz )
 : rxx(prxx),rxy(prxy),rxz(prxz),
   ryx(pryx),ryy(pryy),ryz(pryz),
   rzx(przx),rzy(przy),rzz(przz),
   tx(ptx),ty(pty),tz(ptz)
{}

inline G4AffineTransform&
G4AffineTransform::operator = (const G4AffineTransform& rhs)
{
  if (this == &rhs) { return *this; }
  rxx = rhs.rxx; rxy = rhs.rxy; rxz = rhs.rxz;
  ryx = rhs.ryx; ryy = rhs.ryy; ryz = rhs.ryz;
  rzx = rhs.rzx; rzy = rhs.rzy; rzz = rhs.rzz;
  tx = rhs.tx; ty = rhs.ty; tz = rhs.tz;
  return *this;
}

inline G4AffineTransform
G4AffineTransform::operator * (const G4AffineTransform& tf) const
{
  return G4AffineTransform(rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx,
                           rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy,
                           rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz,

                           ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx,
                           ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy,
                           ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz,

                           rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx,
                           rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy,
                           rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz,

                           tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx,
                           tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty,
                           tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz);
}

inline G4AffineTransform&
G4AffineTransform::operator *= (const G4AffineTransform& tf)
{


  G4double nrxx=rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx;
  G4double nrxy=rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy;
  G4double nrxz=rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz;

  G4double nryx=ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx;
  G4double nryy=ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy;
  G4double nryz=ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz;

  G4double nrzx=rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx;
  G4double nrzy=rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy;
  G4double nrzz=rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz;

  G4double ntx=tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx;
  G4double nty=tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty;
  G4double ntz=tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz;

  tx=ntx; ty=nty; tz=ntz;
  rxx=nrxx; rxy=nrxy; rxz=nrxz;
  ryx=nryx; ryy=nryy; ryz=nryz;
  rzx=nrzx; rzy=nrzy; rzz=nrzz;

  return *this;
}

inline G4AffineTransform&
G4AffineTransform::Product( const G4AffineTransform& tf1,
                            const G4AffineTransform& tf2 )
{
  rxx = tf1.rxx*tf2.rxx + tf1.rxy*tf2.ryx + tf1.rxz*tf2.rzx;
  rxy = tf1.rxx*tf2.rxy + tf1.rxy*tf2.ryy + tf1.rxz*tf2.rzy;
  rxz = tf1.rxx*tf2.rxz + tf1.rxy*tf2.ryz + tf1.rxz*tf2.rzz;

  ryx = tf1.ryx*tf2.rxx + tf1.ryy*tf2.ryx + tf1.ryz*tf2.rzx;
  ryy = tf1.ryx*tf2.rxy + tf1.ryy*tf2.ryy + tf1.ryz*tf2.rzy;
  ryz = tf1.ryx*tf2.rxz + tf1.ryy*tf2.ryz + tf1.ryz*tf2.rzz;

  rzx = tf1.rzx*tf2.rxx + tf1.rzy*tf2.ryx + tf1.rzz*tf2.rzx;
  rzy = tf1.rzx*tf2.rxy + tf1.rzy*tf2.ryy + tf1.rzz*tf2.rzy;
  rzz = tf1.rzx*tf2.rxz + tf1.rzy*tf2.ryz + tf1.rzz*tf2.rzz;

  tx = tf1.tx*tf2.rxx + tf1.ty*tf2.ryx + tf1.tz*tf2.rzx + tf2.tx;
  ty = tf1.tx*tf2.rxy + tf1.ty*tf2.ryy + tf1.tz*tf2.rzy + tf2.ty;
  tz = tf1.tx*tf2.rxz + tf1.ty*tf2.ryz + tf1.tz*tf2.rzz + tf2.tz;

  return *this;
}

inline G4AffineTransform&
G4AffineTransform::InverseProduct( const G4AffineTransform& tf1,
                                   const G4AffineTransform& tf2 )
{
  if ((tf2.rxx + tf2.ryy + tf2.rzz) == 3.)
  {
    rxx = tf1.rxx;
    rxy = tf1.rxy;
    rxz = tf1.rxz;

    ryx = tf1.ryx;
    ryy = tf1.ryy;
    ryz = tf1.ryz;

    rzx = tf1.rzx;
    rzy = tf1.rzy;
    rzz = tf1.rzz;

    tx = tf1.tx - tf2.tx;
    ty = tf1.ty - tf2.ty;
    tz = tf1.tz - tf2.tz;
  }
  else
  {
    G4double tf1rxx = tf1.rxx, tf1rxy = tf1.rxy, tf1rxz = tf1.rxz;
    rxx = tf1rxx*tf2.rxx + tf1rxy*tf2.rxy + tf1rxz*tf2.rxz;
    rxy = tf1rxx*tf2.ryx + tf1rxy*tf2.ryy + tf1rxz*tf2.ryz;
    rxz = tf1rxx*tf2.rzx + tf1rxy*tf2.rzy + tf1rxz*tf2.rzz;

    G4double tf1ryx = tf1.ryx, tf1ryy = tf1.ryy, tf1ryz = tf1.ryz;
    ryx = tf1ryx*tf2.rxx + tf1ryy*tf2.rxy + tf1ryz*tf2.rxz;
    ryy = tf1ryx*tf2.ryx + tf1ryy*tf2.ryy + tf1ryz*tf2.ryz;
    ryz = tf1ryx*tf2.rzx + tf1ryy*tf2.rzy + tf1ryz*tf2.rzz;

    G4double tf1rzx = tf1.rzx, tf1rzy = tf1.rzy, tf1rzz = tf1.rzz;
    rzx = tf1rzx*tf2.rxx + tf1rzy*tf2.rxy + tf1rzz*tf2.rxz;
    rzy = tf1rzx*tf2.ryx + tf1rzy*tf2.ryy + tf1rzz*tf2.ryz;
    rzz = tf1rzx*tf2.rzx + tf1rzy*tf2.rzy + tf1rzz*tf2.rzz;

    G4double tf1_2tx = tf1.tx - tf2.tx;
    G4double tf1_2ty = tf1.ty - tf2.ty;
    G4double tf1_2tz = tf1.tz - tf2.tz;
    tx = tf1_2tx*tf2.rxx + tf1_2ty*tf2.rxy + tf1_2tz*tf2.rxz;
    ty = tf1_2tx*tf2.ryx + tf1_2ty*tf2.ryy + tf1_2tz*tf2.ryz;
    tz = tf1_2tx*tf2.rzx + tf1_2ty*tf2.rzy + tf1_2tz*tf2.rzz;
  }
  return *this;
}

inline G4ThreeVector
G4AffineTransform::TransformPoint(const G4ThreeVector& vec) const
{
  G4double vecx = vec.x(), vecy = vec.y(), vecz = vec.z();
  return { vecx*rxx + vecy*ryx + vecz*rzx + tx,
           vecx*rxy + vecy*ryy + vecz*rzy + ty,
           vecx*rxz + vecy*ryz + vecz*rzz + tz };
}

inline G4ThreeVector
G4AffineTransform::InverseTransformPoint(const G4ThreeVector& vec) const
{
  G4double vecx = vec.x()-tx, vecy = vec.y()-ty, vecz = vec.z()-tz;
  return { vecx*rxx + vecy*rxy + vecz*rxz,
           vecx*ryx + vecy*ryy + vecz*ryz,
           vecx*rzx + vecy*rzy + vecz*rzz };
}

inline G4ThreeVector
G4AffineTransform::TransformAxis(const G4ThreeVector& axis) const
{
  G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
  return { axisx*rxx + axisy*ryx + axisz*rzx,
           axisx*rxy + axisy*ryy + axisz*rzy,
           axisx*rxz + axisy*ryz + axisz*rzz };
}

inline G4ThreeVector
G4AffineTransform::InverseTransformAxis(const G4ThreeVector& axis) const
{
  G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
  return { axisx*rxx + axisy*rxy + axisz*rxz,
           axisx*ryx + axisy*ryy + axisz*ryz,
           axisx*rzx + axisy*rzy + axisz*rzz };
}

inline
void G4AffineTransform::ApplyPointTransform(G4ThreeVector& vec) const
{
  G4double vecx = vec.x(), vecy = vec.y(), vecz = vec.z();
  vec.setX( vecx*rxx + vecy*ryx + vecz*rzx + tx );
  vec.setY( vecx*rxy + vecy*ryy + vecz*rzy + ty );
  vec.setZ( vecx*rxz + vecy*ryz + vecz*rzz + tz );
}

inline
void G4AffineTransform::ApplyAxisTransform(G4ThreeVector& axis) const
{
  G4double axisx = axis.x(), axisy = axis.y(), axisz = axis.z();
  axis.setX( axisx*rxx + axisy*ryx + axisz*rzx );
  axis.setY( axisx*rxy + axisy*ryy + axisz*rzy );
  axis.setZ( axisx*rxz + axisy*ryz + axisz*rzz );
}

inline
G4AffineTransform G4AffineTransform::Inverse() const
{
  G4double ttx = -tx, tty = -ty, ttz = -tz;
  return G4AffineTransform( rxx, ryx, rzx,
                            rxy, ryy, rzy,
                            rxz, ryz, rzz,
                            ttx*rxx + tty*rxy + ttz*rxz,
                            ttx*ryx + tty*ryy + ttz*ryz,
                            ttx*rzx + tty*rzy + ttz*rzz );
}

inline
G4AffineTransform& G4AffineTransform::Invert()
{
  G4double ttx = -tx, tty = -ty, ttz = -tz;
           tx = ttx*rxx + tty*rxy + ttz*rxz;
           ty = ttx*ryx + tty*ryy + ttz*ryz;
           tz = ttx*rzx + tty*rzy + ttz*rzz;

  G4double tmp1=ryx; ryx=rxy; rxy=tmp1;
  G4double tmp2=rzx; rzx=rxz; rxz=tmp2;
  G4double tmp3=rzy; rzy=ryz; ryz=tmp3;

  return *this;
}

inline
G4AffineTransform& G4AffineTransform::operator +=(const G4ThreeVector& tlate)
{
  tx += tlate.x();
  ty += tlate.y();
  tz += tlate.z();

  return *this;
}

inline
G4AffineTransform& G4AffineTransform::operator -=(const G4ThreeVector& tlate)
{
  tx -= tlate.x();
  ty -= tlate.y();
  tz -= tlate.z();

  return *this;
}

inline
G4bool G4AffineTransform::operator == (const G4AffineTransform& tf) const
{
  return tx==tf.tx&&ty==tf.ty&&tz==tf.tz&&
         rxx==tf.rxx&&rxy==tf.rxy&&rxz==tf.rxz&&
         ryx==tf.ryx&&ryy==tf.ryy&&ryz==tf.ryz&&
         rzx==tf.rzx&&rzy==tf.rzy&&rzz==tf.rzz;
}

inline
G4bool G4AffineTransform::operator != (const G4AffineTransform& tf) const
{
  return tx!=tf.tx||ty!=tf.ty||tz!=tf.tz||
         rxx!=tf.rxx||rxy!=tf.rxy||rxz!=tf.rxz||
         ryx!=tf.ryx||ryy!=tf.ryy||ryz!=tf.ryz||
         rzx!=tf.rzx||rzy!=tf.rzy||rzz!=tf.rzz;
}

inline
G4double G4AffineTransform::operator [] (const G4int n) const
{
  G4double v = 0.0;
  switch(n)
  {
    case 0:
            v=rxx;
            break;
    case 1:
            v=rxy;
            break;
    case 2:
            v=rxz;
            break;
    case 4:
            v=ryx;
            break;
    case 5:
            v=ryy;
            break;
    case 6:
            v=ryz;
            break;
    case 8:
            v=rzx;
            break;
    case 9:
            v=rzy;
            break;
    case 10:
            v=rzz;
            break;
    case 12:
            v=tx;
            break;
    case 13:
            v=ty;
            break;
    case 14:
            v=tz;
            break;
    case 3:
    case 7:
    case 11:
            break;
    case 15:
            v=1.0;
            break;
  }
  return v;
}

inline
G4bool G4AffineTransform::IsRotated() const
{
  return !(rxx==1.0 && ryy==1.0 && rzz==1.0);
}

inline
G4bool G4AffineTransform::IsTranslated() const
{
  return (tx != 0.0) || (ty != 0.0) || (tz != 0.0);
}

inline G4RotationMatrix G4AffineTransform::NetRotation() const
{
  return G4Rep3x3(rxx,rxy,rxz,
                  ryx,ryy,ryz,
                  rzx,rzy,rzz);
}

inline G4RotationMatrix G4AffineTransform::InverseNetRotation() const
{
  return G4Rep3x3(rxx,ryx,rzx,
                  rxy,ryy,rzy,
                  rxz,ryz,rzz);
}

inline
G4ThreeVector G4AffineTransform::NetTranslation() const
{
  return {tx,ty,tz};
}

inline
G4ThreeVector G4AffineTransform::InverseNetTranslation() const
{
  G4double ttx = -tx, tty = -ty, ttz = -tz;
  G4double invtx = ttx*rxx + tty*rxy + ttz*rxz;
  G4double invty = ttx*ryx + tty*ryy + ttz*ryz;
  G4double invtz = ttx*rzx + tty*rzy + ttz*rzz;
  return {invtx,invty,invtz};
}

inline
void G4AffineTransform::SetNetRotation(const G4RotationMatrix& rot)
{
  rxx=rot.xx();
  rxy=rot.xy();
  rxz=rot.xz();
  ryx=rot.yx();
  ryy=rot.yy();
  ryz=rot.yz();
  rzx=rot.zx();
  rzy=rot.zy();
  rzz=rot.zz();
}

inline
void G4AffineTransform::SetNetTranslation(const G4ThreeVector& tlate)
{
  tx=tlate.x();
  ty=tlate.y();
  tz=tlate.z();
}

inline
G4AffineTransform::operator G4Transform3D () const
{
  return G4Transform3D(NetRotation().inverse(),NetTranslation());
}

inline
std::ostream& operator << (std::ostream& os, const G4AffineTransform& transf)
{
  std::streamsize oldPrec = os.precision(6);
  G4double DeviationTolerance = 1.0e-05;

  G4double diagDeviation = 0.0;
  G4double offdDeviationUL = 0.0;
  G4double offdDeviationDR = 0.0;
  G4double offdDeviation = 0.0;

  os << "  Transformation: " << std::endl;



  G4bool UnitTr = ! transf.IsRotated();
  diagDeviation = std::max( std::fabs( transf[0] - 1.0 ) ,
                            std::fabs( transf[5] - 1.0 ) );
  diagDeviation = std::max( diagDeviation,
                            std::fabs( transf[10] - 1.0 ) );

  offdDeviationUL = std::max( std::fabs( transf[1] ) ,
                              std::fabs( transf[2] ) );
  offdDeviationUL = std::max( offdDeviationUL,
                              std::fabs( transf[4] ) );

  offdDeviationDR = std::max( std::fabs( transf[6] ) ,
                              std::fabs( transf[8] ) );
  offdDeviationDR = std::max( offdDeviationDR,
                              std::fabs( transf[9] ) );
  offdDeviation = std::max( offdDeviationUL, offdDeviationDR );

  if( UnitTr || std::max(diagDeviation, offdDeviation) < DeviationTolerance )
  {
     os << "    UNIT  Rotation " << std::endl;
  }
  else
  {
     os << "rx/x,y,z: "
        << transf[0] << " " << transf[1] << " " << transf[2] << std::endl
        << "ry/x,y,z: "
        << transf[4] << " " << transf[5] << " " << transf[6] << std::endl
        << "rz/x,y,z: "
        << transf[8] << " " << transf[9] << " " << transf[10] << std::endl;
  }

  os << "tr/x,y,z: " << transf[12] << " " << transf[13] << " " << transf[14]
     << std::endl;

  os.precision(oldPrec);

  return os;
}
# 194 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4AffineTransform.hh" 2 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.hh" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.hh" 1 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.hh" 3
class G4NavigationLevelRep
{

 public:

   inline G4NavigationLevelRep( G4VPhysicalVolume* newPtrPhysVol,
                          const G4AffineTransform& newT,
                                EVolume newVolTp,
                                G4int newRepNo = -1 );

   inline G4NavigationLevelRep( G4VPhysicalVolume* newPtrPhysVol,
                          const G4AffineTransform& levelAbove,
                          const G4AffineTransform& relativeCurrent,
                                EVolume newVolTp,
                                G4int newRepNo = -1 );




   inline G4NavigationLevelRep();
   inline G4NavigationLevelRep( G4NavigationLevelRep& );

   inline ~G4NavigationLevelRep();

   inline G4NavigationLevelRep& operator=(const G4NavigationLevelRep& right);

   inline G4VPhysicalVolume* GetPhysicalVolume();

   inline const G4AffineTransform* GetTransformPtr() const ;
   inline const G4AffineTransform& GetTransform() const ;

   inline EVolume GetVolumeType() const ;
   inline G4int GetReplicaNo() const ;

   inline void AddAReference();
   inline G4bool RemoveAReference();


   inline void* operator new(size_t);

   inline void operator delete(void* aTrack);


 private:

   G4AffineTransform sTransform;



   G4VPhysicalVolume* sPhysicalVolumePtr = nullptr;


   G4int sReplicaNo = -1;
   EVolume sVolumeType;


   G4int fCountRef = 1;

};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.icc" 3
extern G4Allocator<G4NavigationLevelRep>*& aNavigLevelRepAllocator();




inline
G4NavigationLevelRep::G4NavigationLevelRep( G4VPhysicalVolume* pPhysVol,
                                      const G4AffineTransform& afTransform,
                                            EVolume volTp,
                                            G4int repNo )
   : sTransform(afTransform),
      sPhysicalVolumePtr(pPhysVol),
      sReplicaNo(repNo),
      sVolumeType(volTp)
{
}

inline
G4NavigationLevelRep::G4NavigationLevelRep()
   : sVolumeType(kReplica)
{
}

inline
G4NavigationLevelRep::G4NavigationLevelRep( G4VPhysicalVolume* pPhysVol,
                                      const G4AffineTransform& levelAbove,
                                      const G4AffineTransform& relativeCurrent,
                                            EVolume volTp,
                                            G4int repNo )
   : sPhysicalVolumePtr(pPhysVol),
      sReplicaNo(repNo),
      sVolumeType(volTp)
{
  sTransform.InverseProduct( levelAbove, relativeCurrent );
}

inline
G4NavigationLevelRep::G4NavigationLevelRep( G4NavigationLevelRep& right )
   : sTransform(right.sTransform),
      sPhysicalVolumePtr(right.sPhysicalVolumePtr),
      sReplicaNo(right.sReplicaNo),
      sVolumeType(right.sVolumeType)
{
}




inline
G4NavigationLevelRep::~G4NavigationLevelRep()
{
# 90 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.icc" 3
}




inline
G4NavigationLevelRep&
G4NavigationLevelRep::operator=( const G4NavigationLevelRep& right )
{
  if ( &right != this )
  {
    sTransform = right.sTransform;
    sPhysicalVolumePtr = right.sPhysicalVolumePtr;
    sVolumeType = right.sVolumeType;
    sReplicaNo = right.sReplicaNo;
    fCountRef = right.fCountRef;
  }
  return *this;
}




inline
G4VPhysicalVolume*
G4NavigationLevelRep::GetPhysicalVolume()
{
  return sPhysicalVolumePtr;
}

inline
const G4AffineTransform&
G4NavigationLevelRep::GetTransform() const
{
  return sTransform;
}

inline
const G4AffineTransform*
G4NavigationLevelRep::GetTransformPtr() const
{
  return &sTransform;
}

inline
EVolume G4NavigationLevelRep::GetVolumeType() const
{
  return sVolumeType;
}

inline
G4int G4NavigationLevelRep::GetReplicaNo() const
{
  return sReplicaNo;
}

inline
void G4NavigationLevelRep::AddAReference()
{
  ++fCountRef;
}

inline
G4bool G4NavigationLevelRep::RemoveAReference()
{
  return( --fCountRef <= 0 );
}





inline
void* G4NavigationLevelRep::operator new(size_t)
{
  if (aNavigLevelRepAllocator() == nullptr)
  {
    aNavigLevelRepAllocator() = new G4Allocator<G4NavigationLevelRep>;
  }
  return (void *) aNavigLevelRepAllocator()->MallocSingle();
}

inline
void G4NavigationLevelRep::operator delete(void* aLevelRep)
{
  aNavigLevelRepAllocator()->FreeSingle((G4NavigationLevelRep *) aLevelRep);
}
# 111 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevelRep.hh" 2 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.hh" 2 3




class G4NavigationLevel
{

 public:

   G4NavigationLevel(G4VPhysicalVolume* newPtrPhysVol,
                     const G4AffineTransform& newT,
                     EVolume newVolTp,
                     G4int newRepNo = -1);

   G4NavigationLevel(G4VPhysicalVolume* newPtrPhysVol,
                     const G4AffineTransform& levelAbove,
                     const G4AffineTransform& relativeCurrent,
                     EVolume newVolTp,
                     G4int newRepNo = -1);




   G4NavigationLevel();
   G4NavigationLevel( const G4NavigationLevel& );

   ~G4NavigationLevel();

   G4NavigationLevel& operator=(const G4NavigationLevel& right);

   inline G4VPhysicalVolume* GetPhysicalVolume() const;
   inline const G4AffineTransform* GetTransformPtr() const ;
   inline const G4AffineTransform& GetTransform() const ;

   inline EVolume GetVolumeType() const ;
   inline G4int GetReplicaNo() const ;

   inline const G4AffineTransform* GetPtrTransform() const;


   inline void* operator new(size_t);
   inline void operator delete(void* aLevel);


   inline void* operator new(size_t, void*);

   inline void operator delete(void* ptr, void*);




 private:

   G4NavigationLevelRep* fLevelRep;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.icc" 3
extern G4Allocator<G4NavigationLevel>*& aNavigationLevelAllocator();

inline
G4VPhysicalVolume* G4NavigationLevel::GetPhysicalVolume() const
{
  return fLevelRep->GetPhysicalVolume();
}

inline
const G4AffineTransform& G4NavigationLevel::GetTransform() const
{
  return fLevelRep->GetTransform() ;
}

inline
const G4AffineTransform* G4NavigationLevel::GetPtrTransform() const
{
  return fLevelRep->GetTransformPtr() ;
}

inline
EVolume G4NavigationLevel::GetVolumeType() const
{
  return fLevelRep->GetVolumeType() ;
}

inline
G4int G4NavigationLevel::GetReplicaNo() const
{
  return fLevelRep->GetReplicaNo() ;
}




inline
void* G4NavigationLevel::operator new(size_t)
{
  if (aNavigationLevelAllocator() == nullptr)
  {
    aNavigationLevelAllocator() = new G4Allocator<G4NavigationLevel>;
  }
  return (void *) aNavigationLevelAllocator()->MallocSingle();
}



inline
void* G4NavigationLevel::operator new(size_t, void* a)
{
  return a;
}

inline
void G4NavigationLevel::operator delete(void* aLevel)
{
  aNavigationLevelAllocator()->FreeSingle((G4NavigationLevel *) aLevel);
}




inline
void G4NavigationLevel::operator delete(void *, void *)
{
}
# 102 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationLevel.hh" 2 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistoryPool.hh" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistoryPool.hh" 3
class G4NavigationHistoryPool
{
  public:

    static G4NavigationHistoryPool* GetInstance();


    inline std::vector<G4NavigationLevel> * GetNewLevels();


    inline std::vector<G4NavigationLevel> * GetLevels();



    inline void DeRegister(std::vector<G4NavigationLevel> * pLevels);


    void Clean();


    void Print() const;


   ~G4NavigationHistoryPool();


  private:

    G4NavigationHistoryPool();


    inline void Register(std::vector<G4NavigationLevel> * pLevels);


    void Reset();


  private:

    static G4NavigationHistoryPool* fgInstance;

    std::vector<std::vector<G4NavigationLevel> *> fPool;
    std::vector<std::vector<G4NavigationLevel> *> fFree;
};





inline void G4NavigationHistoryPool::
Register(std::vector<G4NavigationLevel> * pLevels)
{
  fPool.push_back(pLevels);
}





inline void G4NavigationHistoryPool::
DeRegister(std::vector<G4NavigationLevel> * pLevels)
{
  fFree.push_back(pLevels);
}





inline std::vector<G4NavigationLevel> * G4NavigationHistoryPool::GetNewLevels()
{
  auto aLevelVec = new std::vector<G4NavigationLevel>(kHistoryMax);
  Register(aLevelVec);

  return aLevelVec;
}






inline std::vector<G4NavigationLevel> * G4NavigationHistoryPool::GetLevels()
{
  std::vector<G4NavigationLevel> * levels = nullptr;

  if (!fFree.empty())
  {
    levels = fFree.back();
    fFree.pop_back();
  }
  else
  {
    levels = GetNewLevels();
  }

  return levels;
}
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 2 3


class G4NavigationHistory
{

 public:

  friend std::ostream&
  operator << (std::ostream& os, const G4NavigationHistory& h);

  G4NavigationHistory();


  ~G4NavigationHistory();


  G4NavigationHistory(const G4NavigationHistory& h);


  inline G4NavigationHistory& operator=(const G4NavigationHistory& h);


  inline void Reset();



  inline void Clear();



  inline void SetFirstEntry(G4VPhysicalVolume* pVol);



  inline const G4AffineTransform& GetTopTransform() const;


  inline const G4AffineTransform* GetPtrTopTransform() const;


  inline G4int GetTopReplicaNo() const;


  inline EVolume GetTopVolumeType() const;


  inline G4VPhysicalVolume* GetTopVolume() const;


  inline std::size_t GetDepth() const;


  inline std::size_t GetMaxDepth() const;



  inline const G4AffineTransform& GetTransform(G4int n) const;


  inline G4int GetReplicaNo(G4int n) const;


  inline EVolume GetVolumeType(G4int n) const;


  inline G4VPhysicalVolume* GetVolume(G4int n) const;


  inline void NewLevel(G4VPhysicalVolume* pNewMother,
                       EVolume vType = kNormal,
                       G4int nReplica = -1);


  inline void BackLevel();



  inline void BackLevel(G4int n);


  inline void *operator new(std::size_t);

  inline void operator delete(void *aHistory);


 private:

  inline void EnlargeHistory();




 private:

  std::vector<G4NavigationLevel>* fNavHistory;


  std::size_t fStackDepth{0};

};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.icc" 1 3
# 30 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.icc" 3
extern G4Allocator<G4NavigationHistory>*& aNavigHistoryAllocator();





inline
void* G4NavigationHistory::operator new(std::size_t)
{
  if (aNavigHistoryAllocator() == nullptr)
  {
    aNavigHistoryAllocator() = new G4Allocator<G4NavigationHistory>;
  }
  return (void *) aNavigHistoryAllocator()->MallocSingle();
}

inline
void G4NavigationHistory::operator delete(void *aHistory)
{
  aNavigHistoryAllocator()->FreeSingle((G4NavigationHistory *) aHistory);
}

inline
G4NavigationHistory&
G4NavigationHistory::operator=(const G4NavigationHistory &h)
{
  if (&h == this) { return *this; }



  if( GetMaxDepth() != h.GetMaxDepth() )
  {
    fNavHistory->resize( h.GetMaxDepth() );
  }

  for ( auto ilev=G4int(h.fStackDepth); ilev>=0; --ilev )
  {
    (*fNavHistory)[ilev] = (*h.fNavHistory)[ilev];
  }
  fStackDepth = h.fStackDepth;

  return *this;
}

inline
void G4NavigationHistory::Reset()
{
  fStackDepth=0;
}

inline
void G4NavigationHistory::Clear()
{
  G4AffineTransform origin(G4ThreeVector(0.,0.,0.));
  G4NavigationLevel tmpNavLevel = G4NavigationLevel(nullptr, origin, kNormal, -1) ;

  Reset();
  for (auto ilev=G4long(fNavHistory->size()-1); ilev>=0; --ilev)
  {
     (*fNavHistory)[ilev] = tmpNavLevel;
  }
}

inline
void G4NavigationHistory::SetFirstEntry(G4VPhysicalVolume* pVol)
{
  G4ThreeVector translation(0.,0.,0.);
  G4int copyNo = -1;




  if( pVol != nullptr )
  {
    translation = pVol->GetTranslation();
    copyNo = pVol->GetCopyNo();
  }
  (*fNavHistory)[0] =
    G4NavigationLevel( pVol, G4AffineTransform(translation), kNormal, copyNo );
}

inline
const G4AffineTransform* G4NavigationHistory::GetPtrTopTransform() const
{
  return (*fNavHistory)[fStackDepth].GetPtrTransform();
}

inline
const G4AffineTransform& G4NavigationHistory::GetTopTransform() const
{
  return (*fNavHistory)[fStackDepth].GetTransform();
}

inline
G4int G4NavigationHistory::GetTopReplicaNo() const
{
  return (*fNavHistory)[fStackDepth].GetReplicaNo();
}

inline
EVolume G4NavigationHistory::GetTopVolumeType() const
{
  return (*fNavHistory)[fStackDepth].GetVolumeType();
}

inline
G4VPhysicalVolume* G4NavigationHistory::GetTopVolume() const
{
  return (*fNavHistory)[fStackDepth].GetPhysicalVolume();
}

inline
std::size_t G4NavigationHistory::GetDepth() const
{
  return fStackDepth;
}

inline
const G4AffineTransform&
G4NavigationHistory::GetTransform(G4int n) const
{
  return (*fNavHistory)[n].GetTransform();
}

inline
G4int G4NavigationHistory::GetReplicaNo(G4int n) const
{
  return (*fNavHistory)[n].GetReplicaNo();
}

inline
EVolume G4NavigationHistory::GetVolumeType(G4int n) const
{
  return (*fNavHistory)[n].GetVolumeType();
}

inline
G4VPhysicalVolume* G4NavigationHistory::GetVolume(G4int n) const
{
  return (*fNavHistory)[n].GetPhysicalVolume();
}

inline
std::size_t G4NavigationHistory::GetMaxDepth() const
{
  return fNavHistory->size();
}

inline
void G4NavigationHistory::BackLevel()
{
  (static_cast <bool> (fStackDepth>0) ? void (0) : __assert_fail ("fStackDepth>0", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.icc", 181, __extension__ __PRETTY_FUNCTION__));




  --fStackDepth;
}

inline
void G4NavigationHistory::BackLevel(G4int n)
{
  (static_cast <bool> (n<=G4int(fStackDepth)) ? void (0) : __assert_fail ("n<=G4int(fStackDepth)", "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.icc", 192, __extension__ __PRETTY_FUNCTION__));
  fStackDepth-=n;
}

inline
void G4NavigationHistory::EnlargeHistory()
{
  std::size_t len = fNavHistory->size();
  if ( len == fStackDepth )
  {


    std::size_t nlen = len+kHistoryStride;
    fNavHistory->resize(nlen);
  }
}


inline
void G4NavigationHistory::NewLevel( G4VPhysicalVolume* pNewMother,
                                    EVolume vType,
                                    G4int nReplica )
{
  ++fStackDepth;
  EnlargeHistory();
  (*fNavHistory)[fStackDepth] =
    G4NavigationLevel( pNewMother,
                       (*fNavHistory)[fStackDepth-1].GetTransform(),
                       G4AffineTransform(pNewMother->GetRotation(),
                       pNewMother->GetTranslation()),
                       vType,
                       nReplica );

}
# 152 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4NavigationHistory.hh" 2 3
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 1 3
# 111 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.hh" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.hh" 3
class G4ProductionCuts;
class G4LogicalVolume;
class G4Material;
class G4VUserRegionInformation;
class G4MaterialCutsCouple;
class G4UserLimits;
class G4FieldManager;
class G4FastSimulationManager;
class G4VPhysicalVolume;
class G4UserSteppingAction;

class G4RegionData
{



  public:

    void initialize()
    {
      fFastSimulationManager = nullptr;
      fRegionalSteppingAction = nullptr;
    }

    G4FastSimulationManager* fFastSimulationManager;
    G4UserSteppingAction* fRegionalSteppingAction;
};
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.hh" 3
using G4RegionManager = G4GeomSplitter<G4RegionData>;

class G4Region
{
  public:

    G4Region(const G4String& name);
    virtual ~G4Region();

    G4Region(const G4Region&) = delete;
    G4Region& operator=(const G4Region&) = delete;


    inline G4bool operator==(const G4Region& rg) const;


    void AddRootLogicalVolume(G4LogicalVolume* lv, G4bool search=true);
    void RemoveRootLogicalVolume(G4LogicalVolume* lv, G4bool scan=true);
# 119 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.hh" 3
    void SetName(const G4String& name);
    inline const G4String& GetName() const;


    inline void RegionModified(G4bool flag);
    inline G4bool IsModified() const;



    inline void SetProductionCuts(G4ProductionCuts* cut);
    inline G4ProductionCuts* GetProductionCuts() const;

    inline std::vector<G4LogicalVolume*>::iterator
           GetRootLogicalVolumeIterator();
    inline std::vector<G4Material*>::const_iterator
           GetMaterialIterator() const;


    inline std::size_t GetNumberOfMaterials() const;
    inline std::size_t GetNumberOfRootVolumes() const;



    void UpdateMaterialList();



    void ClearMaterialList();


    void ScanVolumeTree(G4LogicalVolume* lv, G4bool region);



    inline void SetUserInformation(G4VUserRegionInformation* ui);
    inline G4VUserRegionInformation* GetUserInformation() const;


    inline void SetUserLimits(G4UserLimits* ul);
    inline G4UserLimits* GetUserLimits() const;



    inline void ClearMap();


    inline void RegisterMaterialCouplePair(G4Material* mat,
                                           G4MaterialCutsCouple* couple);


    inline G4MaterialCutsCouple* FindCouple(G4Material* mat);



    void SetFastSimulationManager(G4FastSimulationManager* fsm);
    G4FastSimulationManager* GetFastSimulationManager() const;




    void ClearFastSimulationManager();



    inline void SetFieldManager(G4FieldManager* fm);
    inline G4FieldManager* GetFieldManager() const;





    inline G4VPhysicalVolume* GetWorldPhysical() const;







    void SetWorld(G4VPhysicalVolume* wp);



    G4bool BelongsTo(G4VPhysicalVolume* thePhys) const;



    G4Region* GetParentRegion(G4bool& unique) const;




    void SetRegionalSteppingAction(G4UserSteppingAction* rusa);
    G4UserSteppingAction* GetRegionalSteppingAction() const;


  public:

    G4Region(__void__&);




    inline G4int GetInstanceID() const;


    static const G4RegionManager& GetSubInstanceManager();


    static void Clean();


    inline void UsedInMassGeometry(G4bool val = true);
    inline void UsedInParallelGeometry(G4bool val = true);
    inline G4bool IsInMassGeometry() const;
    inline G4bool IsInParallelGeometry() const;



  private:

    inline void AddMaterial (G4Material* aMaterial);



  private:

    using G4RootLVList = std::vector<G4LogicalVolume*>;
    using G4MaterialList = std::vector<G4Material*>;
    using G4MaterialCouplePair = std::pair<G4Material*, G4MaterialCutsCouple*>;
    using G4MaterialCoupleMap = std::map<G4Material*, G4MaterialCutsCouple*>;

    G4String fName;

    G4RootLVList fRootVolumes;
    G4MaterialList fMaterials;
    G4MaterialCoupleMap fMaterialCoupleMap;

    G4bool fRegionMod = true;
    G4ProductionCuts* fCut = nullptr;

    G4VUserRegionInformation* fUserInfo = nullptr;
    G4UserLimits* fUserLimits = nullptr;
    G4FieldManager* fFieldManager = nullptr;

    G4VPhysicalVolume* fWorldPhys = nullptr;

    G4bool fInMassGeometry = false;
    G4bool fInParallelGeometry = false;

    G4int instanceID;

               static G4RegionManager subInstanceManager;

};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.icc" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.icc" 3
inline
G4bool G4Region::operator==(const G4Region& rg) const
{
  return this==&rg;
}





inline
G4int G4Region::GetInstanceID() const
{
  return instanceID;
}





inline
const G4String& G4Region::GetName() const
{
  return fName;
}





inline
void G4Region::RegionModified(G4bool flag)
{
  fRegionMod = flag;
}





inline
G4bool G4Region::IsModified() const
{
  return fRegionMod;
}





inline
void G4Region::SetProductionCuts(G4ProductionCuts* cut)
{
  fCut = cut;
  fRegionMod = true;
}





inline
G4ProductionCuts* G4Region::GetProductionCuts() const
{
  return fCut;
}





inline
std::vector<G4LogicalVolume*>::iterator
G4Region::GetRootLogicalVolumeIterator()
{
  return G4RootLVList::iterator(fRootVolumes.begin());
}





inline
std::vector<G4Material*>::const_iterator
G4Region::GetMaterialIterator() const
{
  return fMaterials.cbegin();
}





inline
size_t G4Region::GetNumberOfMaterials() const
{
  return fMaterials.size();
}





inline
size_t G4Region::GetNumberOfRootVolumes() const
{
  return fRootVolumes.size();
}





inline
void G4Region::SetUserInformation(G4VUserRegionInformation* ui)
{
  fUserInfo = ui;
}





inline
G4VUserRegionInformation* G4Region::GetUserInformation() const
{
  return fUserInfo;
}





inline
void G4Region::SetUserLimits(G4UserLimits* ul)
{
  fUserLimits = ul;
}





inline
G4UserLimits* G4Region::GetUserLimits() const
{
  return fUserLimits;
}





inline
void G4Region::ClearMap()
{
  if(!(fMaterialCoupleMap.empty()))
  {
    auto b = fMaterialCoupleMap.cbegin();
    auto e = fMaterialCoupleMap.cend();
    fMaterialCoupleMap.erase(b,e);
  }
}





inline
void G4Region::RegisterMaterialCouplePair(G4Material* mat,
                                          G4MaterialCutsCouple* couple)
{
  fMaterialCoupleMap.insert(G4MaterialCouplePair(mat,couple));
}





inline
G4MaterialCutsCouple* G4Region::FindCouple(G4Material* mat)
{
  auto c = fMaterialCoupleMap.find(mat);
  G4MaterialCutsCouple* couple = nullptr;
  if(c!=fMaterialCoupleMap.cend()) couple = (*c).second;
  return couple;
}





inline
G4FieldManager* G4Region::GetFieldManager() const
{
  return fFieldManager;
}





inline
void G4Region::SetFieldManager(G4FieldManager* fm)
{
  fFieldManager = fm;
}





inline
G4VPhysicalVolume* G4Region::GetWorldPhysical() const
{
  return fWorldPhys;
}





inline
void G4Region::AddMaterial(G4Material* aMaterial)
{
  auto pos = std::find(fMaterials.cbegin(),fMaterials.cend(),aMaterial);
  if (pos == fMaterials.cend())
  {
    fMaterials.push_back(aMaterial);
    fRegionMod = true;
  }
}





inline
void G4Region::UsedInMassGeometry(G4bool val)
{
  fInMassGeometry = val;
}





inline
void G4Region::UsedInParallelGeometry(G4bool val)
{
  fInParallelGeometry = val;
}





inline
G4bool G4Region::IsInMassGeometry() const
{
  return fInMassGeometry;
}





inline
G4bool G4Region::IsInParallelGeometry() const
{
  return fInParallelGeometry;
}
# 276 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Region.hh" 2 3
# 112 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 2 3






class G4FieldManager;
class G4Material;
class G4VSensitiveDetector;
class G4VSolid;
class G4UserLimits;
class G4SmartVoxelHeader;
class G4FastSimulationManager;
class G4MaterialCutsCouple;
class G4VisAttributes;

class G4LVData
{



  public:

    G4LVData();
    void initialize()
    {
      fSolid = nullptr;
      fSensitiveDetector = nullptr;
      fFieldManager = nullptr;
      fMaterial = nullptr;
      fMass = 0.0;
      fCutsCouple = nullptr;
    }

  public:

    G4VSolid* fSolid = nullptr;

    G4VSensitiveDetector* fSensitiveDetector = nullptr;

    G4FieldManager* fFieldManager = nullptr;

    G4Material* fMaterial = nullptr;

    G4double fMass = 0.0;

    G4MaterialCutsCouple* fCutsCouple = nullptr;

};
# 180 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 3
using G4LVManager = G4GeomSplitter<G4LVData>;

class G4LogicalVolume
{
  public:

    G4LogicalVolume(G4VSolid* pSolid,
                    G4Material* pMaterial,
              const G4String& name,
                    G4FieldManager* pFieldMgr = nullptr,
                    G4VSensitiveDetector* pSDetector = nullptr,
                    G4UserLimits* pULimits = nullptr,
                    G4bool optimise = true);







    virtual ~G4LogicalVolume();




    G4LogicalVolume(const G4LogicalVolume&) = delete;
    G4LogicalVolume& operator=(const G4LogicalVolume&) = delete;


    inline const G4String& GetName() const;
    void SetName(const G4String& pName);


    inline std::size_t GetNoDaughters() const;

    inline G4VPhysicalVolume* GetDaughter(const std::size_t i) const;


    void AddDaughter(G4VPhysicalVolume* p);

    inline G4bool IsDaughter(const G4VPhysicalVolume* p) const;


    G4bool IsAncestor(const G4VPhysicalVolume* p) const;



    void RemoveDaughter(const G4VPhysicalVolume* p);


    void ClearDaughters();


    G4int TotalVolumeEntities() const;


    inline EVolume CharacteriseDaughters() const;

    inline EVolume DeduceDaughtersType() const;


    G4VSolid* GetSolid() const;
    void SetSolid(G4VSolid* pSolid);


    G4Material* GetMaterial() const;
    void SetMaterial(G4Material* pMaterial);

    void UpdateMaterial(G4Material* pMaterial);



    G4double GetMass(G4bool forced = false, G4bool propagate = true,
                     G4Material* parMaterial = nullptr);
# 267 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 3
    void ResetMass();




    G4FieldManager* GetFieldManager() const;

    void SetFieldManager(G4FieldManager* pFieldMgr, G4bool forceToAllDaughters);






    G4VSensitiveDetector* GetSensitiveDetector() const;

    void SetSensitiveDetector(G4VSensitiveDetector* pSDetector);


    inline G4UserLimits* GetUserLimits() const;
    inline void SetUserLimits(G4UserLimits *pULimits);


    inline G4SmartVoxelHeader* GetVoxelHeader() const;
    inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);


    inline G4double GetSmartless() const;
    inline void SetSmartless(G4double s);


    inline G4bool IsToOptimise() const;


    inline void SetOptimisation(G4bool optim);




    inline G4bool IsRootRegion() const;

    inline void SetRegionRootFlag(G4bool rreg);

    inline G4bool IsRegion() const;

    inline void SetRegion(G4Region* reg);

    inline G4Region* GetRegion() const;

    inline void PropagateRegion();


    const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
    void SetMaterialCutsCouple(G4MaterialCutsCouple* cuts);


    G4bool operator == (const G4LogicalVolume& lv) const;



    const G4VisAttributes* GetVisAttributes () const;
    void SetVisAttributes (const G4VisAttributes* pVA);
    void SetVisAttributes (const G4VisAttributes& VA);



    inline G4FastSimulationManager* GetFastSimulationManager () const;


    inline void SetBiasWeight (G4double w);
    inline G4double GetBiasWeight() const;


  public:

    G4LogicalVolume(__void__&);




    virtual G4bool IsExtended() const;


    inline G4FieldManager* GetMasterFieldManager() const;

    inline G4VSensitiveDetector* GetMasterSensitiveDetector() const;

    inline G4VSolid* GetMasterSolid() const;


    inline G4int GetInstanceID() const;


    static const G4LVManager& GetSubInstanceManager();


    static void Clean();


    inline void Lock();


    void InitialiseWorker(G4LogicalVolume* ptrMasterObject,
                          G4VSolid* pSolid, G4VSensitiveDetector* pSDetector);



    void TerminateWorker(G4LogicalVolume* ptrMasterObject);



    void AssignFieldManager(G4FieldManager* fldMgr);


    static G4VSolid* GetSolid(G4LVData& instLVdata) ;
    static void SetSolid(G4LVData& instLVdata, G4VSolid* pSolid);


    G4bool ChangeDaughtersType(EVolume atype);





  private:

    using G4PhysicalVolumeList = std::vector<G4VPhysicalVolume *>;

               static G4LVManager subInstanceManager;


    G4PhysicalVolumeList fDaughters;

    G4String fName;

    G4UserLimits* fUserLimits = nullptr;

    G4SmartVoxelHeader* fVoxel = nullptr;

    G4double fSmartless = 2.0;


    G4Region* fRegion = nullptr;

    G4double fBiasWeight = 1.0;

    std::shared_ptr<const G4VisAttributes> fVisAttributes;






    G4VSolid* fSolid = nullptr;
    G4VSensitiveDetector* fSensitiveDetector = nullptr;
    G4FieldManager* fFieldManager = nullptr;
    G4LVData* lvdata = nullptr;

    G4int instanceID;

    EVolume fDaughtersVolumeType;

    G4bool fOptimise = true;

    G4bool fRootRegion = false;

    G4bool fLock = false;

};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.icc" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.icc" 3
inline
const G4String& G4LogicalVolume::GetName() const
{
  return fName;
}





inline
G4int G4LogicalVolume::GetInstanceID() const
{
  return instanceID;
}





inline
G4FieldManager* G4LogicalVolume::GetMasterFieldManager() const
{
  return fFieldManager;
}





inline
std::size_t G4LogicalVolume::GetNoDaughters() const
{
  return fDaughters.size();
}





inline
G4VPhysicalVolume* G4LogicalVolume::GetDaughter(const std::size_t i) const
{
  return fDaughters[i];
}





inline
G4FastSimulationManager* G4LogicalVolume::GetFastSimulationManager () const
{
  G4FastSimulationManager* fFSM = nullptr;
  if(fRegion != nullptr) fFSM = fRegion->GetFastSimulationManager();
  return fFSM;
}





inline
G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const
{
  for (const auto & daughter : fDaughters)
  {
    if (*daughter==*p) return true;
  }
  return false;
}





inline
EVolume G4LogicalVolume::CharacteriseDaughters() const
{
  return fDaughtersVolumeType;
}





inline
EVolume G4LogicalVolume::DeduceDaughtersType() const
{
  EVolume type= kNormal;
  G4VPhysicalVolume* pVol;

  if ( GetNoDaughters() >= 1 )
  {
    pVol = GetDaughter(0);
    type = pVol->VolumeType();
  }
  return type;
}





inline
G4VSolid* G4LogicalVolume::GetMasterSolid() const
{
  return fSolid;
}





inline
G4VSensitiveDetector* G4LogicalVolume::GetMasterSensitiveDetector() const
{
  return fSensitiveDetector;
}





inline
G4UserLimits* G4LogicalVolume::GetUserLimits() const
{
  if(fUserLimits != nullptr) return fUserLimits;
  if(fRegion != nullptr) return fRegion->GetUserLimits();
  return nullptr;
}





inline
void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits)
{
  fUserLimits = pULimits;
}





inline
G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const
{
  return fVoxel;
}





inline
void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel)
{
  fVoxel = pVoxel;
}





inline
G4double G4LogicalVolume::GetSmartless() const
{
  return fSmartless;
}





inline
void G4LogicalVolume::SetSmartless(G4double smt)
{
  fSmartless = smt;
}





inline
G4bool G4LogicalVolume::IsToOptimise() const
{
  return fOptimise;
}





inline
void G4LogicalVolume::SetOptimisation(G4bool optim)
{
  fOptimise = optim;
}





inline
G4bool G4LogicalVolume::IsRootRegion() const
{
  return fRootRegion;
}





inline
void G4LogicalVolume::SetRegionRootFlag(G4bool rreg)
{
  fRootRegion = rreg;
}





inline
G4bool G4LogicalVolume::IsRegion() const
{
  G4bool reg = false;
  if (fRegion != nullptr) reg = true;
  return reg;
}





inline
void G4LogicalVolume::SetRegion(G4Region* reg)
{
  fRegion = reg;
}





inline
G4Region* G4LogicalVolume::GetRegion() const
{
  return fRegion;
}





inline
void G4LogicalVolume::PropagateRegion()
{
  fRegion->ScanVolumeTree(this, true);
}





inline
void G4LogicalVolume::Lock()
{
  fLock = true;
}





inline
G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const
{
  return this==&lv;
}





inline
void G4LogicalVolume::SetBiasWeight(G4double weight)
{
  fBiasWeight = weight;
}





inline
G4double G4LogicalVolume::GetBiasWeight() const
{
  return fBiasWeight;
}





inline
const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const
{
  return fVisAttributes.get();
}
# 438 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LogicalVolume.hh" 2 3
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.hh" 2 3





class G4TouchableHistory
{
  public:

    G4TouchableHistory();




    G4TouchableHistory( const G4NavigationHistory& history );


    virtual ~G4TouchableHistory();


    inline virtual G4VPhysicalVolume* GetVolume( G4int depth = 0 ) const;
    inline virtual G4VSolid* GetSolid( G4int depth = 0 ) const;
    virtual const G4ThreeVector& GetTranslation( G4int depth = 0 ) const;
    virtual const G4RotationMatrix* GetRotation( G4int depth = 0 ) const;

    inline virtual G4int GetReplicaNumber( G4int depth = 0 ) const;
    inline G4int GetCopyNumber( G4int depth = 0 ) const;
    inline virtual G4int GetHistoryDepth() const;
    virtual G4int MoveUpHistory( G4int num_levels = 1 );


    virtual void UpdateYourself( G4VPhysicalVolume* pPhysVol,
                            const G4NavigationHistory* history = nullptr );


    inline virtual const G4NavigationHistory* GetHistory() const;


    inline void* operator new(std::size_t);
    inline void operator delete(void* aTH);


   private:

    inline G4int CalculateHistoryIndex( G4int stackDepth ) const;

    G4RotationMatrix frot;
    G4ThreeVector ftlate;
    G4NavigationHistory fhistory;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.icc" 3
extern G4Allocator<G4TouchableHistory>*& aTouchableHistoryAllocator();

inline
void G4TouchableHistory::UpdateYourself( G4VPhysicalVolume* pPhysVol,
                                          const G4NavigationHistory* pHistory )
{
  fhistory = *pHistory;
  const G4AffineTransform& tf = fhistory.GetTopTransform();
  if( pPhysVol == nullptr )
  {




    fhistory.SetFirstEntry(pPhysVol);
  }
  ftlate = tf.InverseNetTranslation();
  frot = tf.InverseNetRotation();
}

inline
G4int G4TouchableHistory::CalculateHistoryIndex( G4int stackDepth ) const
{
  return G4int(fhistory.GetDepth()-stackDepth);
}

inline
G4VPhysicalVolume* G4TouchableHistory::GetVolume( G4int depth ) const
{
  return fhistory.GetVolume(CalculateHistoryIndex(depth));
}

inline
G4VSolid* G4TouchableHistory::GetSolid( G4int depth ) const
{
  return fhistory.GetVolume(CalculateHistoryIndex(depth))
                            ->GetLogicalVolume()->GetSolid();
}

inline
G4int G4TouchableHistory::GetReplicaNumber( G4int depth ) const
{
  return fhistory.GetReplicaNo(CalculateHistoryIndex(depth));
}

inline
G4int G4TouchableHistory::GetCopyNumber(G4int depth) const
{
  return GetReplicaNumber(depth);
}

inline
G4int G4TouchableHistory::GetHistoryDepth() const
{
  return G4int(fhistory.GetDepth());
}

inline
G4int G4TouchableHistory::MoveUpHistory( G4int num_levels )
{
  auto maxLevelsMove = G4int(fhistory.GetDepth());
  G4int minLevelsMove = 0;



  if( num_levels > maxLevelsMove )
  {
    num_levels = maxLevelsMove;
  }
  else if( num_levels < minLevelsMove )
  {
    num_levels = minLevelsMove;
  }
  fhistory.BackLevel( num_levels );

  return num_levels;
}

inline
const G4NavigationHistory* G4TouchableHistory::GetHistory() const
{
  return &fhistory;
}




inline
void* G4TouchableHistory::operator new(std::size_t)
{



  if (aTouchableHistoryAllocator() == nullptr)
  {
     aTouchableHistoryAllocator() = new G4Allocator<G4TouchableHistory>;
  }
  return (void *) aTouchableHistoryAllocator()->MallocSingle();
}

inline
void G4TouchableHistory::operator delete(void* aTH)
{
  aTouchableHistoryAllocator()->FreeSingle((G4TouchableHistory *) aTH);
}
# 150 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHistory.hh" 2 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VTouchable.hh" 2 3

using G4VTouchable = G4TouchableHistory;
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHandle.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ReferenceCountedHandle.hh" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ReferenceCountedHandle.hh" 3
template <class X>
class G4CountedObject;

template <class X>
class G4ReferenceCountedHandle
{
 public:
  inline G4ReferenceCountedHandle(X* rep = nullptr);


  inline G4ReferenceCountedHandle(const G4ReferenceCountedHandle<X>& right);


  inline ~G4ReferenceCountedHandle();


  inline G4ReferenceCountedHandle<X>& operator=(
    const G4ReferenceCountedHandle<X>& right);


  inline G4ReferenceCountedHandle<X>& operator=(X* objPtr);


  inline unsigned int Count() const;


  inline X* operator->() const;





  inline G4bool operator!() const;


  inline operator bool() const;


  inline X* operator()() const;






  inline void* operator new(std::size_t);


  inline void operator delete(void* pObj);


 private:
  G4CountedObject<X>* fObj = nullptr;

};

extern G4Allocator<G4ReferenceCountedHandle<void>>*& aRCHAllocator();

template <class X>
class G4CountedObject
{
  friend class G4ReferenceCountedHandle<X>;

 public:
  G4CountedObject(X* pObj = nullptr);


  ~G4CountedObject();


  inline void AddRef();


  inline void Release();






  inline void* operator new(std::size_t);


  inline void operator delete(void* pObj);


 private:
  unsigned int fCount = 0;

  X* fRep = nullptr;

};

extern G4Allocator<G4CountedObject<void>>*&
aCountedObjectAllocator();



template <class X>
G4CountedObject<X>::G4CountedObject(X* pObj)
  : fRep(pObj)
{
  if(pObj != nullptr)
    fCount = 1;
}

template <class X>
G4CountedObject<X>::~G4CountedObject()
{
  delete fRep;
}

template <class X>
void G4CountedObject<X>::AddRef()
{
  ++fCount;
}

template <class X>
void G4CountedObject<X>::Release()
{
  if(--fCount == 0)
    delete this;
}

template <class X>
void* G4CountedObject<X>::operator new(std::size_t)
{
  if(aCountedObjectAllocator() == nullptr)
    aCountedObjectAllocator() = new G4Allocator<G4CountedObject<void>>;
  return ((void*) aCountedObjectAllocator()->MallocSingle());
}

template <class X>
void G4CountedObject<X>::operator delete(void* pObj)
{
  aCountedObjectAllocator()->FreeSingle((G4CountedObject<void>*) pObj);
}



template <class X>
G4ReferenceCountedHandle<X>::G4ReferenceCountedHandle(X* rep)
{
  if(rep != nullptr)
    fObj = new G4CountedObject<X>(rep);
}

template <class X>
G4ReferenceCountedHandle<X>::G4ReferenceCountedHandle(
  const G4ReferenceCountedHandle<X>& right)
  : fObj(right.fObj)
{
  fObj->AddRef();
}

template <class X>
G4ReferenceCountedHandle<X>::~G4ReferenceCountedHandle()
{
  if(fObj != nullptr)
    fObj->Release();
}

template <class X>
G4ReferenceCountedHandle<X>& G4ReferenceCountedHandle<X>::operator=(
  const G4ReferenceCountedHandle<X>& right)
{
  if(fObj != right.fObj)
  {
    if(fObj != nullptr)
      fObj->Release();
    this->fObj = right.fObj;
    fObj->AddRef();
  }
  return *this;
}

template <class X>
G4ReferenceCountedHandle<X>& G4ReferenceCountedHandle<X>::operator=(X* objPtr)
{
  if(fObj != nullptr)
    fObj->Release();
  this->fObj = new G4CountedObject<X>(objPtr);
  return *this;
}

template <class X>
unsigned int G4ReferenceCountedHandle<X>::Count() const
{
  return ((fObj != nullptr) ? fObj->fCount : 0);
}

template <class X>
X* G4ReferenceCountedHandle<X>::operator->() const
{
  return ((fObj != nullptr) ? fObj->fRep : 0);
}

template <class X>
G4bool G4ReferenceCountedHandle<X>::operator!() const
{
  return fObj == nullptr;
}

template <class X>
G4ReferenceCountedHandle<X>::operator bool() const
{
  return fObj != nullptr;
}

template <class X>
X* G4ReferenceCountedHandle<X>::operator()() const
{
  return ((fObj != nullptr) ? fObj->fRep : nullptr);
}

template <class X>
void* G4ReferenceCountedHandle<X>::operator new(std::size_t)
{
  if(aRCHAllocator() == nullptr)
    aRCHAllocator() = new G4Allocator<G4ReferenceCountedHandle<void>>;
  return ((void*) aRCHAllocator()->MallocSingle());
}

template <class X>
void G4ReferenceCountedHandle<X>::operator delete(void* pObj)
{
  aRCHAllocator()->FreeSingle((G4ReferenceCountedHandle<void>*) pObj);
}
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TouchableHandle.hh" 2 3

using G4TouchableHandle = G4ReferenceCountedHandle<G4VTouchable>;
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 1 3
# 92 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 1 3
# 80 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElementTable.hh" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElementTable.hh" 3
class G4Element;

using G4ElementTable = std::vector<G4Element*>;
# 81 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElementVector.hh" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElementVector.hh" 3
class G4Element;

using G4ElementVector = std::vector<const G4Element*>;
# 82 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IonisParamElm.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IonisParamElm.hh" 3
class G4IonisParamElm
{
 public:
  G4IonisParamElm(G4double Z);
  ~G4IonisParamElm();
  G4IonisParamElm& operator=(const G4IonisParamElm&) = delete;
  G4IonisParamElm(G4IonisParamElm&) = delete;




  G4double GetZ() const { return fZ; }


  G4double GetZ3() const { return fZ3; }


  G4double GetZZ3() const { return fZZ3; }


  G4double GetlogZ3() const { return flogZ3; }


  G4double GetTau0() const { return fTau0; };


  G4double GetTaul() const { return fTaul; }


  G4double GetAlow() const { return fAlow; }
  G4double GetBlow() const { return fBlow; }
  G4double GetClow() const { return fClow; }


  G4double GetMeanExcitationEnergy() const { return fMeanExcitationEnergy; }

  G4double GetFermiVelocity() const { return fVFermi; };
  G4double GetLFactor() const { return fLFactor; };


  G4double* GetShellCorrectionVector() const { return fShellCorrectionVector; }

  G4bool operator==(const G4IonisParamElm&) const = delete;
  G4bool operator!=(const G4IonisParamElm&) const = delete;

 private:



  G4double fZ;
  G4double fZ3;
  G4double fZZ3;
  G4double flogZ3;



  G4double fTau0;
  G4double fTaul;
  G4double fBetheBlochLow;
  G4double fAlow, fBlow, fClow;
  G4double fMeanExcitationEnergy;
  G4double* fShellCorrectionVector;


  G4double fVFermi;
  G4double fLFactor;
};
# 83 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Isotope.hh" 1 3
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Isotope.hh" 3
class G4Isotope;
using G4IsotopeTable = std::vector<G4Isotope*>;

class G4Isotope
{
 public:

  G4Isotope(const G4String& name,
    G4int z,
    G4int n,
    G4double a = 0.,
    G4int mlevel = 0);

  ~G4Isotope();

  G4Isotope(const G4Isotope&) = delete;
  G4Isotope& operator=(const G4Isotope&) = delete;


  const G4String& GetName() const { return fName; }


  G4int GetZ() const { return fZ; }


  G4int GetN() const { return fN; }


  G4double GetA() const { return fA; }


  G4int Getm() const { return fm; }

  static G4Isotope* GetIsotope(const G4String& name, G4bool warning = false);

  static const G4IsotopeTable* GetIsotopeTable();

  static size_t GetNumberOfIsotopes();

  size_t GetIndex() const { return fIndexInTable; }

  friend std::ostream& operator<<(std::ostream&, const G4Isotope*);

  friend std::ostream& operator<<(std::ostream&, const G4Isotope&);

  friend std::ostream& operator<<(std::ostream&, const G4IsotopeTable&);

  G4bool operator==(const G4Isotope&) const;
  G4bool operator!=(const G4Isotope&) const;

  void SetName(const G4String& name) { fName = name; }

 private:
  G4String fName;
  G4int fZ;
  G4int fN;
  G4double fA;
  G4int fm;

  static G4IsotopeTable theIsotopeTable;

  size_t fIndexInTable;
};
# 84 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IsotopeVector.hh" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IsotopeVector.hh" 3
using G4IsotopeVector = std::vector<G4Isotope*>;
# 85 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Element.hh" 2 3





class G4Element
{
 public:

  G4Element(const G4String& name,
    const G4String& symbol,
    G4double Zeff,
    G4double Aeff);


  G4Element(const G4String& name,
    const G4String& symbol,
    G4int nbIsotopes);

  virtual ~G4Element();

  G4Element(G4Element&) = delete;
  const G4Element& operator=(const G4Element&) = delete;


  void AddIsotope(G4Isotope* isotope,
    G4double RelativeAbundance);



  inline const G4String& GetName() const { return fName; }
  inline const G4String& GetSymbol() const { return fSymbol; }


  inline G4double GetZ() const { return fZeff; }
  inline G4int GetZasInt() const { return fZ; }


  inline G4double GetN() const { return fNeff; }
  inline G4double GetAtomicMassAmu() const { return fNeff; }


  inline G4double GetA() const { return fAeff; }

  inline G4bool GetNaturalAbundanceFlag() const;

  inline void SetNaturalAbundanceFlag(G4bool);


  inline G4int GetNbOfAtomicShells() const { return fNbOfAtomicShells; }


  G4double GetAtomicShell(G4int index) const;


  G4int GetNbOfShellElectrons(G4int index) const;


  inline size_t GetNumberOfIsotopes() const { return fNumberOfIsotopes; }


  inline G4IsotopeVector* GetIsotopeVector() const { return theIsotopeVector; }


  inline G4double* GetRelativeAbundanceVector() const { return fRelativeAbundanceVector; }

  inline const G4Isotope* GetIsotope(G4int iso) const { return (*theIsotopeVector)[iso]; }


  static G4ElementTable* GetElementTable();

  static size_t GetNumberOfElements();


  inline size_t GetIndex() const { return fIndexInTable; }


  static G4Element* GetElement(const G4String& name, G4bool warning = true);


  inline G4double GetfCoulomb() const { return fCoulomb; }


  inline G4double GetfRadTsai() const { return fRadTsai; }


  inline G4IonisParamElm* GetIonisation() const { return fIonisation; }


  friend std::ostream& operator<<(std::ostream&, const G4Element*);
  friend std::ostream& operator<<(std::ostream&, const G4Element&);
  friend std::ostream& operator<<(std::ostream&, const G4ElementTable&);
  friend std::ostream& operator<<(std::ostream&, const G4ElementVector&);

  inline void SetName(const G4String& name) { fName = name; }

  G4bool operator==(const G4Element&) const = delete;
  G4bool operator!=(const G4Element&) const = delete;

 private:
  void InitializePointers();
  void ComputeDerivedQuantities();
  void ComputeCoulombFactor();
  void ComputeLradTsaiFactor();
  void AddNaturalIsotopes();



  G4String fName;
  G4String fSymbol;
  G4double fZeff;
  G4double fNeff;
  G4double fAeff;
  G4int fZ;

  G4int fNbOfAtomicShells;
  G4double* fAtomicShells;
  G4int* fNbOfShellElectrons;

  G4int fNumberOfIsotopes;
  G4IsotopeVector* theIsotopeVector;
  G4double* fRelativeAbundanceVector;



  static G4ElementTable theElementTable;
  size_t fIndexInTable;
  G4bool fNaturalAbundance;



  G4double fCoulomb;
  G4double fRadTsai;
  G4IonisParamElm* fIonisation;
};

inline G4bool G4Element::GetNaturalAbundanceFlag() const { return fNaturalAbundance; }

inline void G4Element::SetNaturalAbundanceFlag(G4bool val) { fNaturalAbundance = val; }
# 93 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IonisParamMat.hh" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IonisParamMat.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DensityEffectCalculator.hh" 1 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DensityEffectCalculator.hh" 3
class G4Material;

class G4DensityEffectCalculator
{
 public:
  G4DensityEffectCalculator(const G4Material*, G4int);
  ~G4DensityEffectCalculator();


  G4double ComputeDensityCorrection(G4double x);

 private:
# 72 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DensityEffectCalculator.hh" 3
  G4double FermiDeltaCalculation(G4double x);

  G4double Newton(G4double x0, G4bool first);

  G4double DFRho(G4double);

  G4double FRho(G4double);

  G4double DEll(G4double);

  G4double Ell(G4double);

  G4double DeltaOnceSolved(G4double);

  const G4Material* fMaterial;
  G4int fVerbose{0};
  G4int fWarnings{0};
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DensityEffectCalculator.hh" 3
  const G4int nlev;

  G4double fConductivity;


  G4double sternx;



  G4double plasmaE;



  G4double meanexcite;







  G4double* sternf;
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DensityEffectCalculator.hh" 3
  G4double* levE;




  G4double* sternl;


  G4double* sternEbar;
};
# 42 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4IonisParamMat.hh" 2 3



class G4Material;
class G4DensityEffectData;

class G4IonisParamMat
{
 public:
  G4IonisParamMat(const G4Material*);
  ~G4IonisParamMat();
  G4IonisParamMat& operator=(const G4IonisParamMat&) = delete;
  G4IonisParamMat(const G4IonisParamMat&) = delete;


  inline G4double GetMeanExcitationEnergy() const { return fMeanExcitationEnergy; };

  void SetMeanExcitationEnergy(G4double value);
  G4double FindMeanExcitationEnergy(const G4Material*) const;

  inline G4double GetLogMeanExcEnergy() const { return fLogMeanExcEnergy; };
  inline G4double* GetShellCorrectionVector() const { return fShellCorrectionVector; };
  inline G4double GetTaul() const { return fTaul; };


  inline G4double GetPlasmaEnergy() const { return fPlasmaEnergy; };
  inline G4double GetAdjustmentFactor() const { return fAdjustmentFactor; };
  inline G4double GetCdensity() const { return fCdensity; };
  inline G4double GetMdensity() const { return fMdensity; };
  inline G4double GetAdensity() const { return fAdensity; };
  inline G4double GetX0density() const { return fX0density; };
  inline G4double GetX1density() const { return fX1density; };
  inline G4double GetD0density() const { return fD0density; };


  void SetDensityEffectParameters(
    G4double cd, G4double md, G4double ad, G4double x0, G4double x1, G4double d0);


  void SetDensityEffectParameters(const G4Material* bmat);

  void ComputeDensityEffectOnFly(G4bool);

  inline G4DensityEffectCalculator* GetDensityEffectCalculator() const
  {
    return fDensityEffectCalc;
  }



  inline G4double DensityCorrection(G4double x) const
  {
    return (nullptr == fDensityEffectCalc) ? GetDensityCorrection(x)
                                           : fDensityEffectCalc->ComputeDensityCorrection(x);
  }


  G4double GetDensityCorrection(G4double x) const;

  static G4DensityEffectData* GetDensityEffectData();


  inline G4double GetF1fluct() const { return fF1fluct; };
  inline G4double GetF2fluct() const { return fF2fluct; };
  inline G4double GetEnergy1fluct() const { return fEnergy1fluct; };
  inline G4double GetLogEnergy1fluct() const { return fLogEnergy1fluct; };
  inline G4double GetEnergy2fluct() const { return fEnergy2fluct; };
  inline G4double GetLogEnergy2fluct() const { return fLogEnergy2fluct; };
  inline G4double GetEnergy0fluct() const { return fEnergy0fluct; };
  inline G4double GetRateionexcfluct() const { return fRateionexcfluct; };


  inline G4double GetZeffective() const { return fZeff; };
  inline G4double GetFermiEnergy() const { return fFermiEnergy; };
  inline G4double GetLFactor() const { return fLfactor; };
  inline G4double GetInvA23() const { return fInvA23; };


  inline void SetBirksConstant(G4double value) { fBirks = value; };
  inline G4double GetBirksConstant() const { return fBirks; };


  inline void SetMeanEnergyPerIonPair(G4double value) { fMeanEnergyPerIon = value; };
  inline G4double GetMeanEnergyPerIonPair() const { return fMeanEnergyPerIon; };


  G4bool operator==(const G4IonisParamMat&) const = delete;
  G4bool operator!=(const G4IonisParamMat&) const = delete;

 private:

  void ComputeMeanParameters();


  void ComputeDensityEffectParameters();


  void ComputeFluctModel();


  void ComputeIonParameters();




  const G4Material* fMaterial;

  G4DensityEffectCalculator* fDensityEffectCalc;
  G4double* fShellCorrectionVector;


  G4double fMeanExcitationEnergy;
  G4double fLogMeanExcEnergy;
  G4double fTaul;


  G4double fCdensity;
  G4double fMdensity;
  G4double fAdensity;
  G4double fX0density;
  G4double fX1density;
  G4double fD0density;

  G4double fPlasmaEnergy;
  G4double fAdjustmentFactor;


  G4double fF1fluct;
  G4double fF2fluct;
  G4double fEnergy1fluct;
  G4double fLogEnergy1fluct;
  G4double fEnergy2fluct;
  G4double fLogEnergy2fluct;
  G4double fEnergy0fluct;
  G4double fRateionexcfluct;


  G4double fZeff;
  G4double fFermiEnergy;
  G4double fLfactor;
  G4double fInvA23;


  G4double fBirks;

  G4double fMeanEnergyPerIon;
  G4double twoln10;


  static G4DensityEffectData* fDensityData;
};
# 95 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesTable.hh" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesTable.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesIndex.hh" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesIndex.hh" 3
enum G4MaterialPropertyIndex {
  kNullPropertyIndex = -1,
  kRINDEX,
  kREFLECTIVITY,
  kREALRINDEX,
  kIMAGINARYRINDEX,
  kEFFICIENCY,
  kTRANSMITTANCE,
  kSPECULARLOBECONSTANT,
  kSPECULARSPIKECONSTANT,
  kBACKSCATTERCONSTANT,
  kGROUPVEL,
  kMIEHG,
  kRAYLEIGH,
  kWLSCOMPONENT,
  kWLSABSLENGTH,
  kWLSCOMPONENT2,
  kWLSABSLENGTH2,
  kABSLENGTH,
  kPROTONSCINTILLATIONYIELD,
  kDEUTERONSCINTILLATIONYIELD,
  kTRITONSCINTILLATIONYIELD,
  kALPHASCINTILLATIONYIELD,
  kIONSCINTILLATIONYIELD,
  kELECTRONSCINTILLATIONYIELD,
  kSCINTILLATIONCOMPONENT1,
  kSCINTILLATIONCOMPONENT2,
  kSCINTILLATIONCOMPONENT3,
  kCOATEDRINDEX,
  kNumberOfPropertyIndex
} ;

enum G4MaterialConstPropertyIndex
{
  kNullConstPropertyIndex = -1,
  kSURFACEROUGHNESS,
  kISOTHERMAL_COMPRESSIBILITY,
  kRS_SCALE_FACTOR,
  kWLSMEANNUMBERPHOTONS,
  kWLSTIMECONSTANT,
  kWLSMEANNUMBERPHOTONS2,
  kWLSTIMECONSTANT2,
  kMIEHG_FORWARD,
  kMIEHG_BACKWARD,
  kMIEHG_FORWARD_RATIO,
  kSCINTILLATIONYIELD,
  kRESOLUTIONSCALE,
  kFERMIPOT,
  kDIFFUSION,
  kSPINFLIP,
  kLOSS,
  kLOSSCS,
  kABSCS,
  kSCATCS,
  kMR_NBTHETA,
  kMR_NBE,
  kMR_RRMS,
  kMR_CORRLEN,
  kMR_THETAMIN,
  kMR_THETAMAX,
  kMR_EMIN,
  kMR_EMAX,
  kMR_ANGNOTHETA,
  kMR_ANGNOPHI,
  kMR_ANGCUT,
  kSCINTILLATIONTIMECONSTANT1,
  kSCINTILLATIONTIMECONSTANT2,
  kSCINTILLATIONTIMECONSTANT3,
  kSCINTILLATIONRISETIME1,
  kSCINTILLATIONRISETIME2,
  kSCINTILLATIONRISETIME3,
  kSCINTILLATIONYIELD1,
  kSCINTILLATIONYIELD2,
  kSCINTILLATIONYIELD3,
  kPROTONSCINTILLATIONYIELD1,
  kPROTONSCINTILLATIONYIELD2,
  kPROTONSCINTILLATIONYIELD3,
  kDEUTERONSCINTILLATIONYIELD1,
  kDEUTERONSCINTILLATIONYIELD2,
  kDEUTERONSCINTILLATIONYIELD3,
  kTRITONSCINTILLATIONYIELD1,
  kTRITONSCINTILLATIONYIELD2,
  kTRITONSCINTILLATIONYIELD3,
  kALPHASCINTILLATIONYIELD1,
  kALPHASCINTILLATIONYIELD2,
  kALPHASCINTILLATIONYIELD3,
  kIONSCINTILLATIONYIELD1,
  kIONSCINTILLATIONYIELD2,
  kIONSCINTILLATIONYIELD3,
  kELECTRONSCINTILLATIONYIELD1,
  kELECTRONSCINTILLATIONYIELD2,
  kELECTRONSCINTILLATIONYIELD3,
  kCOATEDTHICKNESS,
  kCOATEDFRUSTRATEDTRANSMISSION,

  kPROTONSCINTILLATIONTIMECONSTANT1,
  kPROTONSCINTILLATIONTIMECONSTANT2,
  kPROTONSCINTILLATIONTIMECONSTANT3,
  kDEUTERONSCINTILLATIONTIMECONSTANT1,
  kDEUTERONSCINTILLATIONTIMECONSTANT2,
  kDEUTERONSCINTILLATIONTIMECONSTANT3,
  kTRITONSCINTILLATIONTIMECONSTANT1,
  kTRITONSCINTILLATIONTIMECONSTANT2,
  kTRITONSCINTILLATIONTIMECONSTANT3,
  kALPHASCINTILLATIONTIMECONSTANT1,
  kALPHASCINTILLATIONTIMECONSTANT2,
  kALPHASCINTILLATIONTIMECONSTANT3,
  kIONSCINTILLATIONTIMECONSTANT1,
  kIONSCINTILLATIONTIMECONSTANT2,
  kIONSCINTILLATIONTIMECONSTANT3,
  kELECTRONSCINTILLATIONTIMECONSTANT1,
  kELECTRONSCINTILLATIONTIMECONSTANT2,
  kELECTRONSCINTILLATIONTIMECONSTANT3,

  kNumberOfConstPropertyIndex
};
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesTable.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertyVector.hh" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertyVector.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsFreeVector.hh" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsFreeVector.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/basic_file.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/basic_file.h" 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++io.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++io.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/c++io.h" 3
  typedef __gthread_mutex_t __c_lock;



  typedef FILE __c_file;


}
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux/bits/basic_file.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _CharT>
    class __basic_file;


  template<>
    class __basic_file<char>
    {

      __c_file* _M_cfile;


      bool _M_cfile_created;

    public:
      __basic_file(__c_lock* __lock = 0) throw ();


      __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept
      : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created)
      {
 __rv._M_cfile = nullptr;
 __rv._M_cfile_created = false;
      }

      __basic_file& operator=(const __basic_file&) = delete;
      __basic_file& operator=(__basic_file&&) = delete;

      void
      swap(__basic_file& __f) noexcept
      {
 std::swap(_M_cfile, __f._M_cfile);
 std::swap(_M_cfile_created, __f._M_cfile_created);
      }


      __basic_file*
      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);






      __basic_file*
      sys_open(__c_file* __file, ios_base::openmode);

      __basic_file*
      sys_open(int __fd, ios_base::openmode __mode) throw ();

      __basic_file*
      close();

      __attribute__ ((__pure__)) bool
      is_open() const throw ();

      __attribute__ ((__pure__)) int
      fd() throw ();

      __attribute__ ((__pure__)) __c_file*
      file() throw ();

      ~__basic_file();

      streamsize
      xsputn(const char* __s, streamsize __n);

      streamsize
      xsputn_2(const char* __s1, streamsize __n1,
        const char* __s2, streamsize __n2);

      streamsize
      xsgetn(char* __s, streamsize __n);

      streamoff
      seekoff(streamoff __off, ios_base::seekdir __way) throw ();

      int
      sync();

      streamsize
      showmanyc();







      using native_handle_type = int;


      native_handle_type
      native_handle() const noexcept;

    };


}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 2 3





# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/version.h" 1 3
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Path, typename _Result = _Path, typename _Path2
    = decltype(std::declval<_Path&>().make_preferred().filename())>
    using _If_fs_path = enable_if_t<is_same_v<_Path, _Path2>, _Result>;
# 91 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
    {

      template<typename _Tp>
 using __chk_state = __and_<is_copy_assignable<_Tp>,
       is_copy_constructible<_Tp>,
       is_default_constructible<_Tp>>;

      static_assert(__chk_state<typename _Traits::state_type>::value,
      "state_type must be CopyAssignable, CopyConstructible"
      " and DefaultConstructible");

      static_assert(is_same<typename _Traits::pos_type,
       fpos<typename _Traits::state_type>>::value,
      "pos_type must be fpos<state_type>");

    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef __basic_file<char> __file_type;
      typedef typename traits_type::state_type __state_type;
      typedef codecvt<char_type, char, __state_type> __codecvt_type;

      friend class ios_base;

    protected:


      __c_lock _M_lock;


      __file_type _M_file;


      ios_base::openmode _M_mode;


      __state_type _M_state_beg;




      __state_type _M_state_cur;



      __state_type _M_state_last;


      char_type* _M_buf;






      size_t _M_buf_size;


      bool _M_buf_allocated;
# 167 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      bool _M_reading;
      bool _M_writing;







      char_type _M_pback;
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;



      const __codecvt_type* _M_codecvt;






      char* _M_ext_buf;




      streamsize _M_ext_buf_size;






      const char* _M_ext_next;
      char* _M_ext_end;






      void
      _M_create_pback()
      {
 if (!_M_pback_init)
   {
     _M_pback_cur_save = this->gptr();
     _M_pback_end_save = this->egptr();
     this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
     _M_pback_init = true;
   }
      }






      void
      _M_destroy_pback() throw()
      {
 if (_M_pback_init)
   {

     _M_pback_cur_save += this->gptr() != this->eback();
     this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
     _M_pback_init = false;
   }
      }

    public:







      basic_filebuf();


      basic_filebuf(const basic_filebuf&) = delete;
      basic_filebuf(basic_filebuf&&);





      virtual
      ~basic_filebuf()
      {
 try
   { this->close(); }
 catch(...)
   { }
      }


      basic_filebuf& operator=(const basic_filebuf&) = delete;
      basic_filebuf& operator=(basic_filebuf&&);
      void swap(basic_filebuf&);






      [[__nodiscard__]]
      bool
      is_open() const throw()
      { return _M_file.is_open(); }
# 322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
# 343 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      __filebuf_type*
      open(const std::string& __s, ios_base::openmode __mode)
      { return open(__s.c_str(), __mode); }
# 354 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, __filebuf_type*>
 open(const _Path& __s, ios_base::openmode __mode)
 { return open(__s.c_str(), __mode); }
# 373 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      __filebuf_type*
      close();
# 406 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
    protected:
      void
      _M_allocate_internal_buffer();

      void
      _M_destroy_internal_buffer() throw();


      virtual streamsize
      showmanyc();






      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = _Traits::eof());
# 435 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      virtual int_type
      overflow(int_type __c = _Traits::eof());



      bool
      _M_convert_to_external(char_type*, streamsize);
# 455 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n);

      virtual pos_type
      seekoff(off_type __off, ios_base::seekdir __way,
       ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual pos_type
      seekpos(pos_type __pos,
       ios_base::openmode __mode = ios_base::in | ios_base::out);


      pos_type
      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);

      int
      _M_get_ext_pos(__state_type &__state);

      virtual int
      sync();

      virtual void
      imbue(const locale& __loc);

      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);

      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);


      bool
      _M_terminate_output();
# 501 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      _M_set_buffer(streamsize __off)
      {
 const bool __testin = _M_mode & ios_base::in;
 const bool __testout = (_M_mode & ios_base::out
    || _M_mode & ios_base::app);

 if (__testin && __off > 0)
   this->setg(_M_buf, _M_buf, _M_buf + __off);
 else
   this->setg(_M_buf, _M_buf, _M_buf);

 if (__testout && __off == 0 && _M_buf_size > 1 )
   this->setp(_M_buf, _M_buf + _M_buf_size - 1);
 else
   this->setp(0, 0);
      }
    };
# 534 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ifstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 561 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      basic_ifstream() : __istream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 571 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      explicit
      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 604 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      explicit
      basic_ifstream(const std::string& __s,
       ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 621 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_ifstream(const _Path& __s,
         ios_base::openmode __mode = ios_base::in)
 : basic_ifstream(__s.c_str(), __mode)
 { }


      basic_ifstream(const basic_ifstream&) = delete;

      basic_ifstream(basic_ifstream&& __rhs)
      : __istream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __istream_type::set_rdbuf(&_M_filebuf); }
# 642 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      ~basic_ifstream()
      { }




      basic_ifstream&
      operator=(const basic_ifstream&) = delete;

      basic_ifstream&
      operator=(basic_ifstream&& __rhs)
      {
 __istream_type::operator=(std::move(__rhs));
 _M_filebuf = std::move(__rhs._M_filebuf);
 return *this;
      }

      void
      swap(basic_ifstream& __rhs)
      {
 __istream_type::swap(__rhs);
 _M_filebuf.swap(__rhs._M_filebuf);
      }
# 674 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      [[__nodiscard__]]
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      [[__nodiscard__]]
      bool
      is_open()
      { return _M_filebuf.is_open(); }



      [[__nodiscard__]]
      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 703 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const char* __s, ios_base::openmode __mode = ios_base::in)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::in))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 742 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::in))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 762 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s, ios_base::openmode __mode = ios_base::in)
 { open(__s.c_str(), __mode); }
# 775 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 790 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
    };
# 807 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ofstream : public basic_ostream<_CharT,_Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 834 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      basic_ofstream(): __ostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 844 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      explicit
      basic_ofstream(const char* __s,
       ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 879 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      explicit
      basic_ofstream(const std::string& __s,
       ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 896 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_ofstream(const _Path& __s,
         ios_base::openmode __mode = ios_base::out)
 : basic_ofstream(__s.c_str(), __mode)
 { }


      basic_ofstream(const basic_ofstream&) = delete;

      basic_ofstream(basic_ofstream&& __rhs)
      : __ostream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __ostream_type::set_rdbuf(&_M_filebuf); }
# 917 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      ~basic_ofstream()
      { }




      basic_ofstream&
      operator=(const basic_ofstream&) = delete;

      basic_ofstream&
      operator=(basic_ofstream&& __rhs)
      {
 __ostream_type::operator=(std::move(__rhs));
 _M_filebuf = std::move(__rhs._M_filebuf);
 return *this;
      }

      void
      swap(basic_ofstream& __rhs)
      {
 __ostream_type::swap(__rhs);
 _M_filebuf.swap(__rhs._M_filebuf);
      }
# 949 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      [[__nodiscard__]]
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      [[__nodiscard__]]
      bool
      is_open()
      { return _M_filebuf.is_open(); }



      [[__nodiscard__]]
      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 978 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const char* __s, ios_base::openmode __mode = ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::out))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 1017 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const std::string& __s, ios_base::openmode __mode = ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::out))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 1037 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s, ios_base::openmode __mode = ios_base::out)
 { open(__s.c_str(), __mode); }
# 1050 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 1065 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
    };
# 1082 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_fstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ios<char_type, traits_type> __ios_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 1110 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      basic_fstream()
      : __iostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }






      explicit
      basic_fstream(const char* __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(0), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 1149 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      explicit
      basic_fstream(const std::string& __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(0), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }







      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_fstream(const _Path& __s,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
 : basic_fstream(__s.c_str(), __mode)
 { }


      basic_fstream(const basic_fstream&) = delete;

      basic_fstream(basic_fstream&& __rhs)
      : __iostream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __iostream_type::set_rdbuf(&_M_filebuf); }
# 1185 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      ~basic_fstream()
      { }




      basic_fstream&
      operator=(const basic_fstream&) = delete;

      basic_fstream&
      operator=(basic_fstream&& __rhs)
      {
 __iostream_type::operator=(std::move(__rhs));
 _M_filebuf = std::move(__rhs._M_filebuf);
 return *this;
      }

      void
      swap(basic_fstream& __rhs)
      {
 __iostream_type::swap(__rhs);
 _M_filebuf.swap(__rhs._M_filebuf);
      }
# 1217 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      [[__nodiscard__]]
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      [[__nodiscard__]]
      bool
      is_open()
      { return _M_filebuf.is_open(); }



      [[__nodiscard__]]
      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 1246 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const char* __s,
    ios_base::openmode __mode = ios_base::in | ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 1287 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      open(const std::string& __s,
    ios_base::openmode __mode = ios_base::in | ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 1308 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
 { open(__s.c_str(), __mode); }
# 1322 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 1337 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 3
    };



  template <class _CharT, class _Traits>
    inline void
    swap(basic_filebuf<_CharT, _Traits>& __x,
  basic_filebuf<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_ifstream<_CharT, _Traits>& __x,
  basic_ifstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_ofstream<_CharT, _Traits>& __x,
  basic_ofstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_fstream<_CharT, _Traits>& __x,
  basic_fstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }



}

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/fstream.tcc" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/fstream.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++11-extensions"





namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_allocate_internal_buffer()
    {


      if (!_M_buf_allocated && !_M_buf)
 {
   _M_buf = new char_type[_M_buf_size];
   _M_buf_allocated = true;
 }
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_destroy_internal_buffer() throw()
    {
      if (_M_buf_allocated)
 {
   delete [] _M_buf;
   _M_buf = 0;
   _M_buf_allocated = false;
 }
      delete [] _M_ext_buf;
      _M_ext_buf = 0;
      _M_ext_buf_size = 0;
      _M_ext_next = 0;
      _M_ext_end = 0;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
    _M_state_last(), _M_buf(0), _M_buf_size(8192),
    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
    _M_ext_end(0)
    {
      _M_codecvt = std::__try_use_facet<__codecvt_type>(this->_M_buf_locale);
    }


  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf(basic_filebuf&& __rhs)
    : __streambuf_type(__rhs),
    _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock),
    _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))),
    _M_state_beg(std::move(__rhs._M_state_beg)),
    _M_state_cur(std::move(__rhs._M_state_cur)),
    _M_state_last(std::move(__rhs._M_state_last)),
    _M_buf(std::__exchange(__rhs._M_buf, nullptr)),
    _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)),
    _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)),
    _M_reading(std::__exchange(__rhs._M_reading, false)),
    _M_writing(std::__exchange(__rhs._M_writing, false)),
    _M_pback(__rhs._M_pback),
    _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)),
    _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)),
    _M_pback_init(std::__exchange(__rhs._M_pback_init, false)),
    _M_codecvt(__rhs._M_codecvt),
    _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)),
    _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)),
    _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)),
    _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr))
    {
      __rhs._M_set_buffer(-1);
      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>&
    basic_filebuf<_CharT, _Traits>::
    operator=(basic_filebuf&& __rhs)
    {
      this->close();
      __streambuf_type::operator=(__rhs);
      _M_file.swap(__rhs._M_file);
      _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0));
      _M_state_beg = std::move(__rhs._M_state_beg);
      _M_state_cur = std::move(__rhs._M_state_cur);
      _M_state_last = std::move(__rhs._M_state_last);
      _M_buf = std::__exchange(__rhs._M_buf, nullptr);
      _M_buf_size = std::__exchange(__rhs._M_buf_size, 1);
      _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false);
      _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr);
      _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0);
      _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr);
      _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr);
      _M_reading = std::__exchange(__rhs._M_reading, false);
      _M_writing = std::__exchange(__rhs._M_writing, false);
      _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr);
      _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr);
      _M_pback_init = std::__exchange(__rhs._M_pback_init, false);
      __rhs._M_set_buffer(-1);
      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
      return *this;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    swap(basic_filebuf& __rhs)
    {
      __streambuf_type::swap(__rhs);
      _M_file.swap(__rhs._M_file);
      std::swap(_M_mode, __rhs._M_mode);
      std::swap(_M_state_beg, __rhs._M_state_beg);
      std::swap(_M_state_cur, __rhs._M_state_cur);
      std::swap(_M_state_last, __rhs._M_state_last);
      std::swap(_M_buf, __rhs._M_buf);
      std::swap(_M_buf_size, __rhs._M_buf_size);
      std::swap(_M_buf_allocated, __rhs._M_buf_allocated);
      std::swap(_M_ext_buf, __rhs._M_ext_buf);
      std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size);
      std::swap(_M_ext_next, __rhs._M_ext_next);
      std::swap(_M_ext_end, __rhs._M_ext_end);
      std::swap(_M_reading, __rhs._M_reading);
      std::swap(_M_writing, __rhs._M_writing);
      std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save);
      std::swap(_M_pback_end_save, __rhs._M_pback_end_save);
      std::swap(_M_pback_init, __rhs._M_pback_init);
    }


  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    open(const char* __s, ios_base::openmode __mode)
    {
      __filebuf_type *__ret = 0;
      if (!this->is_open())
 {
   _M_file.open(__s, __mode);
   if (this->is_open())
     {
       _M_allocate_internal_buffer();
       _M_mode = __mode;


       _M_reading = false;
       _M_writing = false;
       _M_set_buffer(-1);


       _M_state_last = _M_state_cur = _M_state_beg;


       if ((__mode & ios_base::ate)
    && this->seekoff(0, ios_base::end, __mode)
    == pos_type(off_type(-1)))
  this->close();
       else
  __ret = this;
     }
 }
      return __ret;
    }
# 251 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/fstream.tcc" 3
  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    close()
    {
      if (!this->is_open())
 return 0;

      bool __testfail = false;
      {

 struct __close_sentry
 {
   basic_filebuf *__fb;
   __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
   ~__close_sentry ()
   {
     __fb->_M_mode = ios_base::openmode(0);
     __fb->_M_pback_init = false;
     __fb->_M_destroy_internal_buffer();
     __fb->_M_reading = false;
     __fb->_M_writing = false;
     __fb->_M_set_buffer(-1);
     __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
   }
 } __cs (this);

 try
   {
     if (!_M_terminate_output())
       __testfail = true;
   }
 catch(...)
   {
     _M_file.close();
     throw;
   }
      }

      if (!_M_file.close())
 __testfail = true;

      if (__testfail)
 return 0;
      else
 return this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    showmanyc()
    {
      streamsize __ret = -1;
      const bool __testin = _M_mode & ios_base::in;
      if (__testin && this->is_open())
 {


   __ret = this->egptr() - this->gptr();







   if (__check_facet(_M_codecvt).encoding() >= 0)

     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }



   _M_destroy_pback();

   if (this->gptr() < this->egptr())
     return traits_type::to_int_type(*this->gptr());


   const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;


   bool __got_eof = false;

   streamsize __ilen = 0;
   codecvt_base::result __r = codecvt_base::ok;
   if (__check_facet(_M_codecvt).always_noconv())
     {
       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
          __buflen);
       if (__ilen == 0)
  __got_eof = true;
     }
   else
     {


       const int __enc = _M_codecvt->encoding();
       streamsize __blen;
       streamsize __rlen;
       if (__enc > 0)
  __blen = __rlen = __buflen * __enc;
       else
  {
    __blen = __buflen + _M_codecvt->max_length() - 1;
    __rlen = __buflen;
  }
       const streamsize __remainder = _M_ext_end - _M_ext_next;
       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;



       if (_M_reading && this->egptr() == this->eback() && __remainder)
  __rlen = 0;



       if (_M_ext_buf_size < __blen)
  {
    char* __buf = new char[__blen];
    if (__remainder)
      __builtin_memcpy(__buf, _M_ext_next, __remainder);

    delete [] _M_ext_buf;
    _M_ext_buf = __buf;
    _M_ext_buf_size = __blen;
  }
       else if (__remainder)
  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

       _M_ext_next = _M_ext_buf;
       _M_ext_end = _M_ext_buf + __remainder;
       _M_state_last = _M_state_cur;

       do
  {
    if (__rlen > 0)
      {



        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
   {
     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid"));


   }
        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
        if (__elen == 0)
   __got_eof = true;
        else if (__elen == -1)
   break;
        _M_ext_end += __elen;
      }

    char_type* __iend = this->eback();
    if (_M_ext_next < _M_ext_end)
      __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
      _M_ext_end, _M_ext_next,
      this->eback(),
      this->eback() + __buflen, __iend);
    if (__r == codecvt_base::noconv)
      {
        size_t __avail = _M_ext_end - _M_ext_buf;
        __ilen = std::min(__avail, __buflen);
        traits_type::copy(this->eback(),
     reinterpret_cast<char_type*>
     (_M_ext_buf), __ilen);
        _M_ext_next = _M_ext_buf + __ilen;
      }
    else
      __ilen = __iend - this->eback();




    if (__r == codecvt_base::error)
      break;

    __rlen = 1;
  }
       while (__ilen == 0 && !__got_eof);
     }

   if (__ilen > 0)
     {
       _M_set_buffer(__ilen);
       _M_reading = true;
       __ret = traits_type::to_int_type(*this->gptr());
     }
   else if (__got_eof)
     {



       _M_set_buffer(-1);
       _M_reading = false;


       if (__r == codecvt_base::partial)
  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file"));

     }
   else if (__r == codecvt_base::error)
     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file"));

   else
     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file"), (*__errno_location ()));

 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    pbackfail(int_type __i)
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }


   const bool __testpb = _M_pback_init;
   const bool __testeof = traits_type::eq_int_type(__i, __ret);
   int_type __tmp;
   if (this->eback() < this->gptr())
     {
       this->gbump(-1);
       __tmp = traits_type::to_int_type(*this->gptr());
     }
   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
     {
       __tmp = this->underflow();
       if (traits_type::eq_int_type(__tmp, __ret))
  return __ret;
     }
   else
     {





       return __ret;
     }



   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
     __ret = __i;
   else if (__testeof)
     __ret = traits_type::not_eof(__i);
   else if (!__testpb)
     {
       _M_create_pback();
       _M_reading = true;
       *this->gptr() = traits_type::to_char_type(__i);
       __ret = __i;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    overflow(int_type __c)
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);
      const bool __testout = (_M_mode & ios_base::out
         || _M_mode & ios_base::app);
      if (__testout)
 {
          if (_M_reading)
            {
              _M_destroy_pback();
              const int __gptr_off = _M_get_ext_pos(_M_state_last);
              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
                  == pos_type(off_type(-1)))
                return __ret;
            }
   if (this->pbase() < this->pptr())
     {

       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }



       if (_M_convert_to_external(this->pbase(),
      this->pptr() - this->pbase()))
  {
    _M_set_buffer(0);
    __ret = traits_type::not_eof(__c);
  }
     }
   else if (_M_buf_size > 1)
     {



       _M_set_buffer(0);
       _M_writing = true;
       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }
       __ret = traits_type::not_eof(__c);
     }
   else
     {

       char_type __conv = traits_type::to_char_type(__c);
       if (__testeof || _M_convert_to_external(&__conv, 1))
  {
    _M_writing = true;
    __ret = traits_type::not_eof(__c);
  }
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
    {

      streamsize __elen;
      streamsize __plen;
      if (__check_facet(_M_codecvt).always_noconv())
 {
   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
   __plen = __ilen;
 }
      else
 {


   streamsize __blen = __ilen * _M_codecvt->max_length();
   char* __buf = static_cast<char*>(__builtin_alloca(__blen));

   char* __bend;
   const char_type* __iend;
   codecvt_base::result __r;
   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
    __iend, __buf, __buf + __blen, __bend);

   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
     __blen = __bend - __buf;
   else if (__r == codecvt_base::noconv)
     {

       __buf = reinterpret_cast<char*>(__ibuf);
       __blen = __ilen;
     }
   else
     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));


   __elen = _M_file.xsputn(__buf, __blen);
   __plen = __blen;


   if (__r == codecvt_base::partial && __elen == __plen)
     {
       const char_type* __iresume = __iend;
       streamsize __rlen = this->pptr() - __iend;
       __r = _M_codecvt->out(_M_state_cur, __iresume,
        __iresume + __rlen, __iend, __buf,
        __buf + __blen, __bend);
       if (__r != codecvt_base::error)
  {
    __rlen = __bend - __buf;
    __elen = _M_file.xsputn(__buf, __rlen);
    __plen = __rlen;
  }
       else
  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));

     }
 }
      return __elen == __plen;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsgetn(_CharT* __s, streamsize __n)
    {

      streamsize __ret = 0;
      if (_M_pback_init)
 {
   if (__n > 0 && this->gptr() == this->eback())
     {
       *__s++ = *this->gptr();
       this->gbump(1);
       __ret = 1;
       --__n;
     }
   _M_destroy_pback();
 }
      else if (_M_writing)
 {
   if (overflow() == traits_type::eof())
     return __ret;
   _M_set_buffer(-1);
   _M_writing = false;
 }




      const bool __testin = _M_mode & ios_base::in;
      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;

      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
   && __testin)
 {

   const streamsize __avail = this->egptr() - this->gptr();
   if (__avail != 0)
     {
       traits_type::copy(__s, this->gptr(), __avail);
       __s += __avail;
       this->setg(this->eback(), this->gptr() + __avail, this->egptr());
       __ret += __avail;
       __n -= __avail;
     }



   streamsize __len;
   for (;;)
     {
       __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), __n);
       if (__len == -1)
  __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file"), (*__errno_location ()));

       if (__len == 0)
  break;

       __n -= __len;
       __ret += __len;
       if (__n == 0)
  break;

       __s += __len;
     }

   if (__n == 0)
     {

       _M_reading = true;
     }
   else if (__len == 0)
     {



       _M_set_buffer(-1);
       _M_reading = false;
     }
 }
      else
 __ret += __streambuf_type::xsgetn(__s, __n);

      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsputn(const _CharT* __s, streamsize __n)
    {
      streamsize __ret = 0;



      const bool __testout = (_M_mode & ios_base::out
         || _M_mode & ios_base::app);
      if (__check_facet(_M_codecvt).always_noconv()
   && __testout && !_M_reading)
 {
   streamsize __bufavail = this->epptr() - this->pptr();


   if (!_M_writing && _M_buf_size > 1)
     __bufavail = _M_buf_size - 1;

   if (__n >= __bufavail)
     {
       const streamsize __buffill = this->pptr() - this->pbase();
       const char* __buf = reinterpret_cast<const char*>(this->pbase());
       __ret = _M_file.xsputn_2(__buf, __buffill,
           reinterpret_cast<const char*>(__s),
           __n);
       if (__ret == __buffill + __n)
  {
    _M_set_buffer(0);
    _M_writing = true;
  }
       if (__ret > __buffill)
  __ret -= __buffill;
       else
  __ret = 0;
     }
   else
     __ret = __streambuf_type::xsputn(__s, __n);
 }
       else
  __ret = __streambuf_type::xsputn(__s, __n);
       return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
    basic_filebuf<_CharT, _Traits>::
    setbuf(char_type* __s, streamsize __n)
    {
      if (!this->is_open())
 {
   if (__s == 0 && __n == 0)
     _M_buf_size = 1;
   else if (__s && __n > 0)
     {
# 821 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/bits/fstream.tcc" 3
       _M_buf = __s;
       _M_buf_size = __n;
     }
 }
      return this;
    }




  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
    {
      int __width = 0;
      if (_M_codecvt)
 __width = _M_codecvt->encoding();
      if (__width < 0)
 __width = 0;

      pos_type __ret = pos_type(off_type(-1));
      const bool __testfail = __off != 0 && __width <= 0;
      if (this->is_open() && !__testfail)
 {




   bool __no_movement = __way == ios_base::cur && __off == 0
     && (!_M_writing || _M_codecvt->always_noconv());


   if (!__no_movement)
     _M_destroy_pback();






   __state_type __state = _M_state_beg;
   off_type __computed_off = __off * __width;
   if (_M_reading && __way == ios_base::cur)
     {
       __state = _M_state_last;
       __computed_off += _M_get_ext_pos(__state);
     }
   if (!__no_movement)
     __ret = _M_seek(__computed_off, __way, __state);
   else
     {
       if (_M_writing)
  __computed_off = this->pptr() - this->pbase();

       off_type __file_off = _M_file.seekoff(0, ios_base::cur);
       if (__file_off != off_type(-1))
  {
    __ret = __file_off + __computed_off;
    __ret.state(__state);
  }
     }
 }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekpos(pos_type __pos, ios_base::openmode)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (this->is_open())
 {

   _M_destroy_pback();
   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (_M_terminate_output())
 {
   off_type __file_off = _M_file.seekoff(__off, __way);
   if (__file_off != off_type(-1))
     {
       _M_reading = false;
       _M_writing = false;
       _M_ext_next = _M_ext_end = _M_ext_buf;
       _M_set_buffer(-1);
       _M_state_cur = __state;
       __ret = __file_off;
       __ret.state(_M_state_cur);
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    int basic_filebuf<_CharT, _Traits>::
    _M_get_ext_pos(__state_type& __state)
    {
      if (_M_codecvt->always_noconv())
        return this->gptr() - this->egptr();
      else
        {



          const int __gptr_off =
            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
                               this->gptr() - this->eback());
          return _M_ext_buf + __gptr_off - _M_ext_end;
        }
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_terminate_output()
    {

      bool __testvalid = true;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __testvalid = false;
 }


      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
   && __testvalid)
 {



   const size_t __blen = 128;
   char __buf[__blen];
   codecvt_base::result __r;
   streamsize __ilen = 0;

   do
     {
       char* __next;
       __r = _M_codecvt->unshift(_M_state_cur, __buf,
     __buf + __blen, __next);
       if (__r == codecvt_base::error)
  __testvalid = false;
       else if (__r == codecvt_base::ok ||
         __r == codecvt_base::partial)
  {
    __ilen = __next - __buf;
    if (__ilen > 0)
      {
        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
        if (__elen != __ilen)
   __testvalid = false;
      }
  }
     }
   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);

   if (__testvalid)
     {




       const int_type __tmp = this->overflow();
       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
  __testvalid = false;
     }
 }
      return __testvalid;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_filebuf<_CharT, _Traits>::
    sync()
    {


      int __ret = 0;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __ret = -1;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    imbue(const locale& __loc)
    {
      bool __testvalid = true;

      const __codecvt_type* const _M_codecvt_tmp
 = __try_use_facet<__codecvt_type>(__loc);

      if (this->is_open())
 {

   if ((_M_reading || _M_writing)
       && __check_facet(_M_codecvt).encoding() == -1)
     __testvalid = false;
   else
     {
       if (_M_reading)
  {
    if (__check_facet(_M_codecvt).always_noconv())
      {
        if (_M_codecvt_tmp
     && !__check_facet(_M_codecvt_tmp).always_noconv())
   __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
                 != pos_type(off_type(-1));
      }
    else
      {

        _M_ext_next = _M_ext_buf
   + _M_codecvt->length(_M_state_last, _M_ext_buf,
          _M_ext_next,
          this->gptr() - this->eback());
        const streamsize __remainder = _M_ext_end - _M_ext_next;
        if (__remainder)
   __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

        _M_ext_next = _M_ext_buf;
        _M_ext_end = _M_ext_buf + __remainder;
        _M_set_buffer(-1);
        _M_state_last = _M_state_cur = _M_state_beg;
      }
  }
       else if (_M_writing && (__testvalid = _M_terminate_output()))
  _M_set_buffer(-1);
     }
 }

      if (__testvalid)
 _M_codecvt = _M_codecvt_tmp;
      else
 _M_codecvt = 0;
    }




  extern template class basic_filebuf<char>;
  extern template class basic_ifstream<char>;
  extern template class basic_ofstream<char>;
  extern template class basic_fstream<char>;


  extern template class basic_filebuf<wchar_t>;
  extern template class basic_ifstream<wchar_t>;
  extern template class basic_ofstream<wchar_t>;
  extern template class basic_fstream<wchar_t>;




}

#pragma GCC diagnostic pop
# 1373 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/fstream" 2 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 2 3



# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Log.hh" 1 3
# 73 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Log.hh" 3
namespace G4LogConsts
{
  const G4double LOG_UPPER_LIMIT = 1e307;
  const G4double LOG_LOWER_LIMIT = 0;

  const G4double SQRTH = 0.70710678118654752440;
  const G4float MAXNUMF = 3.4028234663852885981170418348451692544e38f;





  union ieee754
  {
    ieee754()= default;
    ieee754(G4double thed) { d = thed; };
    ieee754(uint64_t thell) { ll = thell; };
    ieee754(G4float thef) { f[0] = thef; };
    ieee754(uint32_t thei) { i[0] = thei; };
    G4double d;
    G4float f[2];
    uint32_t i[2];
    uint64_t ll;
    uint16_t s[4];
  };

  inline G4double get_log_px(const G4double x)
  {
    const G4double PX1log = 1.01875663804580931796E-4;
    const G4double PX2log = 4.97494994976747001425E-1;
    const G4double PX3log = 4.70579119878881725854E0;
    const G4double PX4log = 1.44989225341610930846E1;
    const G4double PX5log = 1.79368678507819816313E1;
    const G4double PX6log = 7.70838733755885391666E0;

    G4double px = PX1log;
    px *= x;
    px += PX2log;
    px *= x;
    px += PX3log;
    px *= x;
    px += PX4log;
    px *= x;
    px += PX5log;
    px *= x;
    px += PX6log;
    return px;
  }

  inline G4double get_log_qx(const G4double x)
  {
    const G4double QX1log = 1.12873587189167450590E1;
    const G4double QX2log = 4.52279145837532221105E1;
    const G4double QX3log = 8.29875266912776603211E1;
    const G4double QX4log = 7.11544750618563894466E1;
    const G4double QX5log = 2.31251620126765340583E1;

    G4double qx = x;
    qx += QX1log;
    qx *= x;
    qx += QX2log;
    qx *= x;
    qx += QX3log;
    qx *= x;
    qx += QX4log;
    qx *= x;
    qx += QX5log;
    return qx;
  }




  inline uint64_t dp2uint64(G4double x)
  {
    ieee754 tmp;
    tmp.d = x;
    return tmp.ll;
  }




  inline G4double uint642dp(uint64_t ll)
  {
    ieee754 tmp;
    tmp.ll = ll;
    return tmp.d;
  }




  inline G4float uint322sp(G4int x)
  {
    ieee754 tmp;
    tmp.i[0] = x;
    return tmp.f[0];
  }




  inline uint32_t sp2uint32(G4float x)
  {
    ieee754 tmp;
    tmp.f[0] = x;
    return tmp.i[0];
  }



  inline G4double getMantExponent(const G4double x, G4double& fe)
  {
    uint64_t n = dp2uint64(x);



    uint64_t le = (n >> 52);


    int32_t e =
      (int32_t)le;
    fe = e - 1023;


    n &= 0x800FFFFFFFFFFFFFULL;


    const uint64_t p05 = 0x3FE0000000000000ULL;
    n |= p05;

    return uint642dp(n);
  }



  inline G4float getMantExponentf(const G4float x, G4float& fe)
  {
    uint32_t n = sp2uint32(x);
    int32_t e = (n >> 23) - 127;
    fe = e;


    const uint32_t p05f = 0x3f000000;
    n &= 0x807fffff;
    n |= p05f;

    return uint322sp(n);
  }
}



inline G4double G4Log(G4double x)
{
  const G4double original_x = x;


  G4double fe;
  x = G4LogConsts::getMantExponent(x, fe);


  x > G4LogConsts::SQRTH ? fe += 1. : x += x;
  x -= 1.0;


  G4double px = G4LogConsts::get_log_px(x);


  const G4double x2 = x * x;
  px *= x;
  px *= x2;

  const G4double qx = G4LogConsts::get_log_qx(x);

  G4double res = px / qx;

  res -= fe * 2.121944400546905827679e-4;
  res -= 0.5 * x2;

  res = x + res;
  res += fe * 0.693359375;

  if(original_x > G4LogConsts::LOG_UPPER_LIMIT)
    res = std::numeric_limits<G4double>::infinity();
  if(original_x < G4LogConsts::LOG_LOWER_LIMIT)
    res = -std::numeric_limits<G4double>::quiet_NaN();

  return res;
}



namespace G4LogConsts
{
  const G4float LOGF_UPPER_LIMIT = MAXNUMF;
  const G4float LOGF_LOWER_LIMIT = 0;

  const G4float PX1logf = 7.0376836292E-2f;
  const G4float PX2logf = -1.1514610310E-1f;
  const G4float PX3logf = 1.1676998740E-1f;
  const G4float PX4logf = -1.2420140846E-1f;
  const G4float PX5logf = 1.4249322787E-1f;
  const G4float PX6logf = -1.6668057665E-1f;
  const G4float PX7logf = 2.0000714765E-1f;
  const G4float PX8logf = -2.4999993993E-1f;
  const G4float PX9logf = 3.3333331174E-1f;

  inline G4float get_log_poly(const G4float x)
  {
    G4float y = x * PX1logf;
    y += PX2logf;
    y *= x;
    y += PX3logf;
    y *= x;
    y += PX4logf;
    y *= x;
    y += PX5logf;
    y *= x;
    y += PX6logf;
    y *= x;
    y += PX7logf;
    y *= x;
    y += PX8logf;
    y *= x;
    y += PX9logf;
    return y;
  }

  const G4float SQRTHF = 0.707106781186547524f;
}



inline G4float G4Logf(G4float x)
{
  const G4float original_x = x;

  G4float fe;
  x = G4LogConsts::getMantExponentf(x, fe);

  x > G4LogConsts::SQRTHF ? fe += 1.f : x += x;
  x -= 1.0f;

  const G4float x2 = x * x;

  G4float res = G4LogConsts::get_log_poly(x);
  res *= x2 * x;

  res += -2.12194440e-4f * fe;
  res += -0.5f * x2;

  res = x + res;

  res += 0.693359375f * fe;

  if(original_x > G4LogConsts::LOGF_UPPER_LIMIT)
    res = std::numeric_limits<G4float>::infinity();
  if(original_x < G4LogConsts::LOGF_LOWER_LIMIT)
    res = -std::numeric_limits<G4float>::quiet_NaN();

  return res;
}



void logv(const uint32_t size, G4double const* __restrict__ iarray,
          G4double* __restrict__ oarray);
void G4Logv(const uint32_t size, G4double const* __restrict__ iarray,
            G4double* __restrict__ oarray);
void logfv(const uint32_t size, G4float const* __restrict__ iarray,
           G4float* __restrict__ oarray);
void G4Logfv(const uint32_t size, G4float const* __restrict__ iarray,
             G4float* __restrict__ oarray);
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVectorType.hh" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVectorType.hh" 3
enum G4PhysicsVectorType
{
  T_G4PhysicsFreeVector = 0,
  T_G4PhysicsLinearVector,
  T_G4PhysicsLogVector
};

enum class G4SplineType
{
  Simple = 0,
  Base,
  FixedEdges
};
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 2 3



class G4PhysicsVector
{
public:


  explicit G4PhysicsVector(G4bool spline = false);


  G4PhysicsVector(const G4PhysicsVector&) = default;
  G4PhysicsVector& operator=(const G4PhysicsVector&) = default;


  G4PhysicsVector(const G4PhysicsVector&&) = delete;
  G4PhysicsVector& operator=(const G4PhysicsVector&&) = delete;
  G4bool operator==(const G4PhysicsVector& right) const = delete;
  G4bool operator!=(const G4PhysicsVector& right) const = delete;

  virtual ~G4PhysicsVector() = default;





  inline G4double Value(const G4double energy, std::size_t& lastidx) const;





  inline G4double Value(const G4double energy) const;



  inline G4double GetValue(const G4double energy, G4bool& isOutRange) const;




  inline G4double LogVectorValue(const G4double energy,
                                 const G4double theLogEnergy) const;



  inline G4double LogFreeVectorValue(const G4double energy,
                                     const G4double theLogEnergy) const;



  inline G4double operator[](const std::size_t index) const;
  inline G4double operator()(const std::size_t index) const;




  inline void PutValue(const std::size_t index, const G4double value);





  inline G4double Energy(const std::size_t index) const;
  inline G4double GetLowEdgeEnergy(const std::size_t index) const;


  inline G4double GetMinEnergy() const;
  inline G4double GetMaxEnergy() const;



  inline G4double GetMinValue() const;
  inline G4double GetMaxValue() const;


  inline std::size_t GetVectorLength() const;




  inline std::size_t ComputeLogVectorBin(const G4double logenergy) const;


  inline G4PhysicsVectorType GetType() const;


  inline G4bool GetSpline() const;


  inline void SetVerboseLevel(G4int value);




  inline G4double FindLinearEnergy(const G4double rand) const;



  std::size_t FindBin(const G4double energy, std::size_t idx) const;





  void ScaleVector(const G4double factorE, const G4double factorV);







  void FillSecondDerivatives(const G4SplineType = G4SplineType::Base,
                             const G4double dir1 = 0.0,
                             const G4double dir2 = 0.0);




  G4double GetEnergy(const G4double value) const;


  G4bool Store(std::ofstream& fOut, G4bool ascii = false) const;
  G4bool Retrieve(std::ifstream& fIn, G4bool ascii = false);


  friend std::ostream& operator<<(std::ostream&, const G4PhysicsVector&);
  void DumpValues(G4double unitE = 1.0, G4double unitV = 1.0) const;

protected:


  virtual void Initialise();

  void PrintPutValueError(std::size_t index, G4double value,
                          const G4String& text);

private:

  void ComputeSecDerivative0();
  void ComputeSecDerivative1();
  void ComputeSecDerivative2(const G4double firstPointDerivative,
                             const G4double endPointDerivative);



  inline G4double Interpolation(const std::size_t idx,
                                const G4double energy) const;


  inline std::size_t LogBin(const G4double energy, const G4double loge) const;
  inline std::size_t BinaryBin(const G4double energy) const;
  inline std::size_t GetBin(const G4double energy) const;

protected:

  G4double edgeMin = 0.0;
  G4double edgeMax = 0.0;

  G4double invdBin = 0.0;
  G4double logemin = 0.0;

  G4double iBin1 = 0.0;
  G4double lmin1 = 0.0;

  G4int verboseLevel = 0;
  std::size_t idxmax = 0;
  std::size_t imax1 = 0;
  std::size_t numberOfNodes = 0;
  std::size_t nLogNodes = 0;

  G4PhysicsVectorType type = T_G4PhysicsFreeVector;


  std::vector<G4double> binVector;
  std::vector<G4double> dataVector;
  std::vector<G4double> secDerivative;
  std::vector<std::size_t> scale;

private:

  G4bool useSpline = false;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.icc" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.icc" 3
inline G4double G4PhysicsVector::operator[](const std::size_t index) const
{
  return dataVector[index];
}


inline G4double G4PhysicsVector::operator()(const std::size_t index) const
{
  return dataVector[index];
}


inline G4double G4PhysicsVector::Energy(const std::size_t index) const
{
  return binVector[index];
}


inline G4double
G4PhysicsVector::GetLowEdgeEnergy(const std::size_t index) const
{
  return binVector[index];
}


inline G4double G4PhysicsVector::GetMinEnergy() const
{
  return edgeMin;
}


inline G4double G4PhysicsVector::GetMaxEnergy() const
{
  return edgeMax;
}


inline G4double G4PhysicsVector::GetMinValue() const
{
  return (numberOfNodes > 0) ? dataVector[0] : 0.0;
}


inline G4double G4PhysicsVector::GetMaxValue() const
{
  return (numberOfNodes > 0) ? dataVector[numberOfNodes - 1] : 0.0;
}


inline std::size_t G4PhysicsVector::GetVectorLength() const
{
  return numberOfNodes;
}


inline void G4PhysicsVector::PutValue(std::size_t index, G4double theValue)
{
  if(index >= numberOfNodes)
  {
    PrintPutValueError(index, theValue, "PutValue(..) ");
  }
  else
  {
    dataVector[index] = theValue;
  }
}


inline G4PhysicsVectorType G4PhysicsVector::GetType() const
{
  return type;
}


inline G4bool G4PhysicsVector::GetSpline() const
{
  return useSpline;
}


inline void G4PhysicsVector::SetVerboseLevel(G4int value)
{
  verboseLevel = value;
}


inline G4double
G4PhysicsVector::FindLinearEnergy(const G4double rand) const
{
  return GetEnergy(rand*dataVector[numberOfNodes - 1]);
}


inline G4double G4PhysicsVector::Interpolation(const std::size_t idx,
                                               const G4double e) const
{

  const G4double x1 = binVector[idx];
  const G4double dl = binVector[idx + 1] - x1;

  const G4double y1 = dataVector[idx];
  const G4double dy = dataVector[idx + 1] - y1;




  const G4double b = (e - x1) / dl;

  G4double res = y1 + b * dy;

  if (useSpline)
  {
    const G4double c0 = (2.0 - b) * secDerivative[idx];
    const G4double c1 = (1.0 + b) * secDerivative[idx + 1];
    res += (b * (b - 1.0)) * (c0 + c1) * (dl * dl * (1.0/6.0));
  }

  return res;
}


inline std::size_t G4PhysicsVector::ComputeLogVectorBin(
  const G4double loge) const
{
  return static_cast<std::size_t>( std::min( static_cast<G4int>((loge - logemin) * invdBin),
    static_cast<G4int>(idxmax) ) );
}


inline std::size_t
G4PhysicsVector::LogBin(const G4double e, const G4double loge) const
{
  std::size_t idx =
  scale[std::min( static_cast<G4int>((loge - lmin1) * iBin1),
                  static_cast<G4int>(imax1) )];
  for (; idx <= idxmax; ++idx)
  {
    if (e >= binVector[idx] && e <= binVector[idx + 1]) { break; }
  }
  return idx;
}


inline std::size_t G4PhysicsVector::BinaryBin(const G4double e) const
{

  return std::lower_bound(binVector.cbegin(), binVector.cend(), e) -
    binVector.cbegin() - 1;
}


inline std::size_t G4PhysicsVector::GetBin(const G4double e) const
{
  std::size_t bin;
  switch(type)
  {
    case T_G4PhysicsLogVector:
      bin = ComputeLogVectorBin(G4Log(e));
      break;

    case T_G4PhysicsLinearVector:
      bin = static_cast<std::size_t>( std::min( static_cast<G4int>((e - edgeMin) * invdBin),
                                                static_cast<G4int>(idxmax) ) );
      break;

    default:
      bin = (nLogNodes > 0) ? LogBin(e, G4Log(e)) : BinaryBin(e);
  }
  return bin;
}


inline G4double
G4PhysicsVector::Value(const G4double e, std::size_t& idx) const
{
  G4double res;
  if (idx + 1 < numberOfNodes &&
      e >= binVector[idx] && e <= binVector[idx+1])
  {
    res = Interpolation(idx, e);
  }
  else if (e > edgeMin && e < edgeMax)
  {
    idx = GetBin(e);
    res = Interpolation(idx, e);
  }
  else if(e <= edgeMin)
  {
    res = dataVector[0];
    idx = 0;
  }
  else
  {
    res = dataVector[idxmax + 1];
    idx = idxmax;
  }
  return res;
}


inline G4double G4PhysicsVector::Value(G4double e) const
{
  G4double res;
  if (e > edgeMin && e < edgeMax)
  {
    const std::size_t idx = GetBin(e);
    res = Interpolation(idx, e);
  }
  else if(e <= edgeMin)
  {
    res = dataVector[0];
  }
  else
  {
    res = dataVector[idxmax + 1];
  }
  return res;
}


inline G4double G4PhysicsVector::GetValue(G4double e, G4bool&) const
{
  return Value(e);
}


inline G4double
G4PhysicsVector::LogVectorValue(const G4double e, const G4double loge) const
{
  G4double res;
  if (e > edgeMin && e < edgeMax)
  {
    const std::size_t idx = ComputeLogVectorBin(loge);
    res = Interpolation(idx, e);
  }
  else if (e <= edgeMin)
  {
    res = dataVector[0];
  }
  else
  {
    res = dataVector[idxmax - 1];
  }
  return res;
}


inline G4double
G4PhysicsVector::LogFreeVectorValue(const G4double e, const G4double loge) const
{
  G4double res;
  if (e > edgeMin && e < edgeMax)
  {
    const std::size_t idx = LogBin(e, loge);
    res = Interpolation(idx, e);
  }
  else if (e <= edgeMin)
  {
    res = dataVector[0];
  }
  else
  {
    res = dataVector[idxmax + 1];
  }
  return res;
}
# 237 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsVector.hh" 2 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsFreeVector.hh" 2 3



class G4PhysicsFreeVector : public G4PhysicsVector
{
public:





  explicit G4PhysicsFreeVector(G4bool spline = false);
  explicit G4PhysicsFreeVector(G4int length);
  explicit G4PhysicsFreeVector(std::size_t length, G4bool spline = false);


  explicit G4PhysicsFreeVector(std::size_t length, G4double emin,
                               G4double emax, G4bool spline = false);





  explicit G4PhysicsFreeVector(const std::vector<G4double>& energies,
                               const std::vector<G4double>& values,
                               G4bool spline = false);
  explicit G4PhysicsFreeVector(const G4double* energies, const G4double* values,
                               std::size_t length, G4bool spline = false);

  ~G4PhysicsFreeVector() override = default;


  void PutValues(const std::size_t index,
                 const G4double energy, const G4double value);




  void InsertValues(const G4double energy, const G4double value);

  void EnableLogBinSearch(const G4int n = 1);


  inline void PutValue(const std::size_t index,
                       const G4double e, const G4double value);
};

inline void G4PhysicsFreeVector::PutValue(const std::size_t index,
                                          const G4double e,
                                          const G4double value)
{
  PutValues(index, e, value);
}
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertyVector.hh" 2 3
using G4MaterialPropertyVector = G4PhysicsFreeVector;
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialPropertiesTable.hh" 2 3




class G4MaterialPropertiesTable
{
 public:
  G4MaterialPropertiesTable();
  virtual ~G4MaterialPropertiesTable();


  void AddConstProperty(const G4String& key, G4double propertyValue, G4bool createNewKey = false);
  void AddConstProperty(const char* key, G4double propertyValue, G4bool createNewKey = false);



  G4MaterialPropertyVector* AddProperty(const G4String& key,
    const std::vector<G4double>& photonEnergies, const std::vector<G4double>& propertyValues,
    G4bool createNewKey = false, G4bool spline = false);



  G4MaterialPropertyVector* AddProperty(const char* key, G4double* photonEnergies,
    G4double* propertyValues, G4int numEntries, G4bool createNewKey = false, G4bool spline = false);



  void AddProperty(const G4String& key, G4MaterialPropertyVector* opv, G4bool createNewKey = false);
  void AddProperty(const char* key, G4MaterialPropertyVector* opv, G4bool createNewKey = false);




  void AddProperty(const G4String& key, const G4String& mat);


  void RemoveConstProperty(const G4String& key);
  void RemoveConstProperty(const char* key);


  void RemoveProperty(const G4String& key);
  void RemoveProperty(const char* key);




  G4double GetConstProperty(const G4String& key) const;
  G4double GetConstProperty(const char* key) const;
  G4double GetConstProperty(const G4int index) const;





  G4bool ConstPropertyExists(const G4String& key) const;
  G4bool ConstPropertyExists(const char* key) const;
  G4bool ConstPropertyExists(const G4int index) const;



  G4MaterialPropertyVector* GetProperty(const char* key) const;
  G4MaterialPropertyVector* GetProperty(const G4String& key) const;
  G4MaterialPropertyVector* GetProperty(const G4int index) const;


  void AddEntry(const G4String& key, G4double aPhotonEnergy, G4double aPropertyValue);
  void AddEntry(const char* key, G4double aPhotonEnergy, G4double aPropertyValue);




  G4int GetConstPropertyIndex(const G4String& key) const;




  G4int GetPropertyIndex(const G4String& key) const;


  void DumpTable() const;


  const std::vector<G4String>& GetMaterialPropertyNames() const { return fMatPropNames; }
  const std::vector<G4String>& GetMaterialConstPropertyNames() const { return fMatConstPropNames; }

  const std::vector<G4MaterialPropertyVector*>& GetProperties() const { return fMP; }
  const std::vector<std::pair<G4double, G4bool>>& GetConstProperties() const { return fMCP; }

 private:

  G4MaterialPropertyVector* CalculateGROUPVEL();




  std::vector<G4MaterialPropertyVector*> fMP;





  std::vector<std::pair<G4double, G4bool>> fMCP;

  std::vector<G4String> fMatPropNames;
  std::vector<G4String> fMatConstPropNames;
};
# 96 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialTable.hh" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4MaterialTable.hh" 3
class G4Material;

using G4MaterialTable = std::vector<G4Material*>;
# 97 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SandiaTable.hh" 1 3
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SandiaTable.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4OrderedTable.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4OrderedTable.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DataVector.hh" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DataVector.hh" 3
class G4DataVector : public std::vector<G4double>
{
 public:
  G4DataVector() = default;


  G4DataVector(const G4DataVector&) = default;
  G4DataVector(G4DataVector&&) = default;


  explicit G4DataVector(std::size_t cap);


  G4DataVector(std::size_t cap, G4double value);



  virtual ~G4DataVector() = default;


  G4DataVector& operator=(const G4DataVector&) = default;
  G4DataVector& operator=(G4DataVector&&) = default;


  inline void insertAt(std::size_t, const G4double&);


  inline std::size_t index(const G4double&) const;


  inline G4bool contains(const G4double&) const;


  inline G4bool remove(const G4double&);


  inline std::size_t removeAll(const G4double&);


  enum
  {
    T_G4DataVector = 100
  };

  G4bool Store(std::ofstream& fOut, G4bool ascii = false);
  G4bool Retrieve(std::ifstream& fIn, G4bool ascii = false);


  friend std::ostream& operator<<(std::ostream&, const G4DataVector&);
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DataVector.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DataVector.icc" 3
inline void G4DataVector::insertAt(std::size_t pos, const G4double& a)
{
  auto i = cbegin();
  for(std::size_t ptn = 0; (ptn < pos) && (i != cend()); ++i, ++ptn)
  {
    ;
  }
  if(i != cend())
  {
    insert(i, a);
  }
  else
  {
    push_back(a);
  }
}

inline std::size_t G4DataVector::index(const G4double& a) const
{
  std::size_t ptn = 0;
  for(auto i = cbegin(); i != cend(); ++i, ++ptn)
  {
    if((*i) == a)
    {
      break;
    }
  }
  return ptn;
}

inline G4bool G4DataVector::contains(const G4double& a) const
{
  return (index(a) < size());
}

inline G4bool G4DataVector::remove(const G4double& a)
{
  G4bool found = false;

  for(auto i = cbegin(); i != cend(); ++i)
  {
    if(!(*i != a))
    {
      erase(i);
      found = true;
      break;
    }
  }
  return found;
}

inline std::size_t G4DataVector::removeAll(const G4double& a)
{
  std::size_t ptn = 0;

  for(auto i = cbegin(); i != cend(); ++i)
  {
    if(!(*i != a))
    {
      erase(i);
      ++ptn;
      --i;
    }
  }
  return ptn;
}
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DataVector.hh" 2 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4OrderedTable.hh" 2 3


class G4OrderedTable : public std::vector<G4DataVector*>
{
 public:
  G4OrderedTable() = default;


  explicit G4OrderedTable(std::size_t cap);



  virtual ~G4OrderedTable() = default;


  void clearAndDestroy();


  G4bool Store(const G4String& filename, G4bool ascii = false);


  G4bool Retrieve(const G4String& filename, G4bool ascii = false);


  friend std::ostream& operator<<(std::ostream& out, G4OrderedTable& table);
};
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SandiaTable.hh" 2 3




# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 53 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SandiaTable.hh" 2 3



class G4Material;

class G4SandiaTable
{
 public:
  G4SandiaTable();
  G4SandiaTable(const G4Material*);
  G4SandiaTable(G4int matIndex);
  ~G4SandiaTable();

  G4SandiaTable(G4SandiaTable&) = delete;
  G4SandiaTable& operator=(const G4SandiaTable& right) = delete;


  void GetSandiaCofPerAtom(G4int Z, G4double energy, std::vector<G4double>& coeff) const;

  void GetSandiaCofWater(G4double energy, std::vector<G4double>& coeff) const;

  G4double GetWaterEnergyLimit() const;
  G4double GetWaterCofForMaterial(G4int, G4int) const;

  static G4double GetZtoA(G4int Z);


  G4int GetMatNbOfIntervals() const;
  G4double GetSandiaCofForMaterial(G4int, G4int) const;
  G4double GetSandiaMatTable(G4int, G4int) const;
  const G4double* GetSandiaCofForMaterial(G4double energy) const;

  G4double GetSandiaMatTablePAI(G4int, G4int) const;
  const G4double* GetSandiaCofForMaterialPAI(G4double energy) const;

  inline void SetVerbose(G4int ver) { fVerbose = ver; };







  void Initialize(const G4Material*);

  G4int SandiaIntervals(G4int Z[], G4int el);

  G4int SandiaMixing(G4int Z[], const G4double* fractionW, G4int el, G4int mi);

  G4double GetPhotoAbsorpCof(G4int i, G4int j) const;

  G4int GetMaxInterval() const;

  inline G4bool GetLowerI1() { return fLowerI1; };
  inline void SetLowerI1(G4bool flag) { fLowerI1 = flag; };


  G4bool operator==(const G4SandiaTable&) const = delete;
  G4bool operator!=(const G4SandiaTable&) const = delete;

 private:
  void ComputeMatSandiaMatrix();
  void ComputeMatSandiaMatrixPAI();


  G4double GetSandiaPerAtom(G4int Z, G4int, G4int) const;






  void ComputeMatTable();

  void SandiaSwap(G4double** da, G4int i, G4int j);

  void SandiaSort(G4double** da, G4int sz);

  G4double** GetPointerToCof();


  static G4int fCumulInterval[101];
  static const G4double funitc[5];


  std::vector<G4double> fSandiaCofPerAtom;


  const G4Material* fMaterial;
  G4int fMatNbOfIntervals;
  G4OrderedTable* fMatSandiaMatrix;
  G4OrderedTable* fMatSandiaMatrixPAI;

  static const G4double fSandiaTable[981][5];
  static const G4int fNumberOfElements;
  static const G4int fIntervalLimit;
  static const G4int fNumberOfIntervals;
  static const G4int fH2OlowerInt;


  G4double** fPhotoAbsorptionCof;

  G4int fMaxInterval;
  G4int fVerbose;
  G4bool fLowerI1;
};
# 98 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Material.hh" 2 3








enum G4State
{
  kStateUndefined = 0,
  kStateSolid,
  kStateLiquid,
  kStateGas
};

static const G4double NTP_Temperature = 293.15 * CLHEP::kelvin;

class G4Material
{
 public:

  G4Material(const G4String& name,
    G4double z,
    G4double a,
    G4double density,
    G4State state = kStateUndefined,
    G4double temp = NTP_Temperature,
    G4double pressure = CLHEP::STP_Pressure);



  G4Material(const G4String& name,
    G4double density,
    G4int nComponents,
    G4State state = kStateUndefined,
    G4double temp = NTP_Temperature,
    G4double pressure = CLHEP::STP_Pressure);


  G4Material(const G4String& name,
    G4double density,
    const G4Material* baseMaterial,
    G4State state = kStateUndefined,
    G4double temp = NTP_Temperature,
    G4double pressure = CLHEP::STP_Pressure);

  virtual ~G4Material();





  void SetChemicalFormula(const G4String& chF);
  void SetFreeElectronDensity(G4double val);
  void ComputeDensityEffectOnFly(G4bool val);

  G4Material(const G4Material&) = delete;
  const G4Material& operator=(const G4Material&) = delete;


  void AddElementByNumberOfAtoms(const G4Element* elm, G4int nAtoms);
  inline void AddElement(G4Element* elm, G4int nAtoms) { AddElementByNumberOfAtoms(elm, nAtoms); }


  void AddElementByMassFraction(const G4Element* elm, G4double fraction);
  inline void AddElement(G4Element* elm, G4double frac) { AddElementByMassFraction(elm, frac); }

  void AddMaterial(G4Material* material, G4double fraction);




  inline const G4String& GetName() const { return fName; }
  inline const G4String& GetChemicalFormula() const { return fChemicalFormula; }
  inline G4double GetFreeElectronDensity() const { return fFreeElecDensity; }
  inline G4double GetDensity() const { return fDensity; }
  inline G4State GetState() const { return fState; }
  inline G4double GetTemperature() const { return fTemp; }
  inline G4double GetPressure() const { return fPressure; }


  inline std::size_t GetNumberOfElements() const { return fNumberOfElements; }


  inline const G4ElementVector* GetElementVector() const { return theElementVector; }


  inline const G4double* GetFractionVector() const { return fMassFractionVector; }


  inline const G4int* GetAtomsVector() const { return fAtomsVector; }


  inline const G4Element* GetElement(G4int iel) const { return (*theElementVector)[iel]; }


  inline const G4double* GetVecNbOfAtomsPerVolume() const { return fVecNbOfAtomsPerVolume; }

  inline G4double GetTotNbOfAtomsPerVolume() const { return fTotNbOfAtomsPerVolume; }

  inline G4double GetTotNbOfElectPerVolume() const { return fTotNbOfElectPerVolume; }


  inline const G4double* GetAtomicNumDensityVector() const { return fVecNbOfAtomsPerVolume; }
  inline G4double GetElectronDensity() const { return fTotNbOfElectPerVolume; }


  inline G4double GetRadlen() const { return fRadlen; }


  inline G4double GetNuclearInterLength() const { return fNuclInterLen; }


  inline G4IonisParamMat* GetIonisation() const { return fIonisation; }


  inline G4SandiaTable* GetSandiaTable() const { return fSandiaTable; }


  inline const G4Material* GetBaseMaterial() const { return fBaseMaterial; }


  inline const std::map<G4Material*, G4double>& GetMatComponents() const { return fMatComponents; }


  inline G4double GetMassOfMolecule() const { return fMassOfMolecule; }


  G4double GetZ() const;
  G4double GetA() const;


  void SetMaterialPropertiesTable(G4MaterialPropertiesTable* anMPT);

  inline G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
  {
    return fMaterialPropertiesTable;
  }


  inline std::size_t GetIndex() const { return fIndexInTable; }


  static G4MaterialTable* GetMaterialTable();

  static std::size_t GetNumberOfMaterials();


  static G4Material* GetMaterial(const G4String& name, G4bool warning = true);


  static G4Material* GetMaterial(G4double z, G4double a, G4double dens);


  static G4Material* GetMaterial(std::size_t nComp, G4double dens);


  friend std::ostream& operator<<(std::ostream&, const G4Material*);
  friend std::ostream& operator<<(std::ostream&, const G4Material&);
  friend std::ostream& operator<<(std::ostream&, const G4MaterialTable&);

  inline void SetName(const G4String& name) { fName = name; }

  virtual G4bool IsExtended() const;


  G4bool operator==(const G4Material&) const = delete;
  G4bool operator!=(const G4Material&) const = delete;

 private:
  void InitializePointers();


  void ComputeDerivedQuantities();


  void ComputeRadiationLength();


  void ComputeNuclearInterLength();


  void CopyPointersOfBaseMaterial();

  void FillVectors();

  G4bool IsLocked();

  static G4MaterialTable theMaterialTable;

  const G4Material* fBaseMaterial;
  G4MaterialPropertiesTable* fMaterialPropertiesTable;






  G4ElementVector* theElementVector;
  G4int* fAtomsVector;
  G4double* fMassFractionVector;
  G4double* fVecNbOfAtomsPerVolume;

  G4IonisParamMat* fIonisation;
  G4SandiaTable* fSandiaTable;

  G4double fDensity;
  G4double fFreeElecDensity;
  G4double fTemp;
  G4double fPressure;

  G4double fTotNbOfAtomsPerVolume;
  G4double fTotNbOfElectPerVolume;
  G4double fRadlen;
  G4double fNuclInterLen;
  G4double fMassOfMolecule;

  G4State fState;
  std::size_t fIndexInTable;
  G4int fNumberOfElements;


  G4int fNbComponents;
  G4int fIdxComponent;
  G4bool fMassFraction;


  std::vector<G4int>* fAtoms = nullptr;
  std::vector<G4double>* fElmFrac = nullptr;
  std::vector<const G4Element*>* fElm = nullptr;


  std::map<G4Material*, G4double> fMatComponents;

  G4String fName;
  G4String fChemicalFormula;
};
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 2 3


class G4VProcess;
class G4MaterialCutsCouple;
class G4VSensitiveDetector;

class G4StepPoint
{
  public:

    G4StepPoint() = default;
   ~G4StepPoint()= default;


    G4StepPoint(const G4StepPoint&) = default;
    G4StepPoint& operator=(const G4StepPoint&);


    const G4ThreeVector& GetPosition() const;
    void SetPosition(const G4ThreeVector& aValue);
    void AddPosition(const G4ThreeVector& aValue);


    G4double GetLocalTime() const;
    void SetLocalTime(const G4double aValue);
    void AddLocalTime(const G4double aValue);


    G4double GetGlobalTime() const;
    void SetGlobalTime(const G4double aValue);
    void AddGlobalTime(const G4double aValue);


    G4double GetProperTime() const;
    void SetProperTime(const G4double aValue);
    void AddProperTime(const G4double aValue);


    const G4ThreeVector& GetMomentumDirection() const;
    void SetMomentumDirection(const G4ThreeVector& aValue);
    void AddMomentumDirection(const G4ThreeVector& aValue);


    G4ThreeVector GetMomentum() const;


    G4double GetTotalEnergy() const;


    G4double GetKineticEnergy() const;
    void SetKineticEnergy(const G4double aValue);
    void AddKineticEnergy(const G4double aValue);


    G4double GetVelocity() const;
    void SetVelocity(G4double v);


    G4double GetBeta() const;


    G4double GetGamma() const;


    G4VPhysicalVolume* GetPhysicalVolume() const;

    const G4VTouchable* GetTouchable() const;
    const G4TouchableHandle& GetTouchableHandle() const;
    void SetTouchableHandle(const G4TouchableHandle& apValue);

    G4Material* GetMaterial() const;
    void SetMaterial(G4Material*);

    const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
    void SetMaterialCutsCouple(const G4MaterialCutsCouple*);

    G4VSensitiveDetector* GetSensitiveDetector() const;
    void SetSensitiveDetector(G4VSensitiveDetector*);

    G4double GetSafety() const;
    void SetSafety(const G4double aValue);

    const G4ThreeVector& GetPolarization() const;
    void SetPolarization(const G4ThreeVector& aValue);
    void AddPolarization(const G4ThreeVector& aValue);

    G4StepStatus GetStepStatus() const;
    void SetStepStatus(const G4StepStatus aValue);

    const G4VProcess* GetProcessDefinedStep() const;


    void SetProcessDefinedStep(const G4VProcess* aValue);

    G4double GetMass() const;
    void SetMass(G4double value);

    G4double GetCharge() const;
    void SetCharge(G4double value);

    G4double GetMagneticMoment() const;
    void SetMagneticMoment(G4double value);

    void SetWeight(G4double aValue);
    G4double GetWeight() const;

  private:

    G4ThreeVector fPosition;
    G4double fGlobalTime = 0.0;

    G4double fLocalTime = 0.0;

    G4double fProperTime = 0.0;

    G4ThreeVector fMomentumDirection;
    G4double fKineticEnergy = 0.0;
    G4double fVelocity = 0.0;

    G4TouchableHandle fpTouchable;

    G4Material* fpMaterial = nullptr;

    const G4MaterialCutsCouple* fpMaterialCutsCouple = nullptr;

    G4VSensitiveDetector* fpSensitiveDetector = nullptr;
    G4double fSafety = 0.0;
    G4ThreeVector fPolarization;
    G4StepStatus fStepStatus = fUndefined;

    const G4VProcess* fpProcessDefinedStep = nullptr;

    G4double fMass = 0.0;

    G4double fCharge = 0.0;

    G4double fMagneticMoment = 0.0;

    G4double fWeight = 0.0;

};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.icc" 3
inline const G4ThreeVector& G4StepPoint::GetPosition() const
{
  return fPosition;
}

inline void G4StepPoint::SetPosition(const G4ThreeVector& aValue)
{
  fPosition = aValue;
}

inline void G4StepPoint::AddPosition(const G4ThreeVector& aValue)
{
  fPosition += aValue;
}

inline G4double G4StepPoint::GetLocalTime() const
{
  return fLocalTime;
}

inline void G4StepPoint::SetLocalTime(const G4double aValue)
{
  fLocalTime = aValue;
}

inline void G4StepPoint::AddLocalTime(const G4double aValue)
{
  fLocalTime += aValue;
}

inline G4double G4StepPoint::GetGlobalTime() const
{
  return fGlobalTime;
}

inline void G4StepPoint::SetGlobalTime(const G4double aValue)
{
  fGlobalTime = aValue;
}

inline void G4StepPoint::AddGlobalTime(const G4double aValue)
{
  fGlobalTime += aValue;
}

inline G4double G4StepPoint::GetProperTime() const
{
  return fProperTime;
}

inline void G4StepPoint::SetProperTime(const G4double aValue)
{
  fProperTime = aValue;
}

inline void G4StepPoint::AddProperTime(const G4double aValue)
{
  fProperTime += aValue;
}

inline const G4ThreeVector& G4StepPoint::GetMomentumDirection() const
{
  return fMomentumDirection;
}

inline void G4StepPoint::SetMomentumDirection(const G4ThreeVector& aValue)
{
  fMomentumDirection = aValue;
}

inline void G4StepPoint::AddMomentumDirection(const G4ThreeVector& aValue)
{
  fMomentumDirection += aValue;
}

inline G4ThreeVector G4StepPoint::GetMomentum() const
{
  G4double tMomentum =
    std::sqrt(fKineticEnergy * fKineticEnergy + 2 * fKineticEnergy * fMass);
  return G4ThreeVector(fMomentumDirection.x() * tMomentum,
                       fMomentumDirection.y() * tMomentum,
                       fMomentumDirection.z() * tMomentum);
}

inline G4double G4StepPoint::GetTotalEnergy() const
{
  return fKineticEnergy + fMass;
}

inline G4double G4StepPoint::GetKineticEnergy() const
{
  return fKineticEnergy;
}

inline void G4StepPoint::SetKineticEnergy(const G4double aValue)
{
  fKineticEnergy = aValue;
}

inline void G4StepPoint::AddKineticEnergy(const G4double aValue)
{
  fKineticEnergy += aValue;
}

inline G4double G4StepPoint::GetVelocity() const
{
  return fVelocity;
}

inline void G4StepPoint::SetVelocity(G4double v)
{
  fVelocity = v;
}

inline G4double G4StepPoint::GetBeta() const
{
  return fVelocity / CLHEP::c_light;
}

inline G4double G4StepPoint::GetGamma() const
{
  return (fMass == 0.) ? std::numeric_limits<double>::max() : (fKineticEnergy + fMass) / fMass;

}

inline G4VPhysicalVolume* G4StepPoint::GetPhysicalVolume() const
{
  return fpTouchable->GetVolume();
}

inline const G4VTouchable* G4StepPoint::GetTouchable() const
{
  return fpTouchable();
}

inline const G4TouchableHandle& G4StepPoint::GetTouchableHandle() const
{
  return fpTouchable;
}

inline void G4StepPoint::SetTouchableHandle(const G4TouchableHandle& apValue)
{
  fpTouchable = apValue;
}

inline G4double G4StepPoint::GetSafety() const
{
  return fSafety;
}

inline void G4StepPoint::SetSafety(const G4double aValue)
{
  fSafety = aValue;
}

inline const G4ThreeVector& G4StepPoint::GetPolarization() const
{
  return fPolarization;
}

inline void G4StepPoint::SetPolarization(const G4ThreeVector& aValue)
{
  fPolarization = aValue;
}

inline void G4StepPoint::AddPolarization(const G4ThreeVector& aValue)
{
  fPolarization += aValue;
}

inline G4StepStatus G4StepPoint::GetStepStatus() const
{
  return fStepStatus;
}

inline void G4StepPoint::SetStepStatus(const G4StepStatus aValue)
{
  fStepStatus = aValue;
}

inline const G4VProcess* G4StepPoint::GetProcessDefinedStep() const
{


  return fpProcessDefinedStep;
}

inline void G4StepPoint::SetProcessDefinedStep(const G4VProcess* aValue)
{
  fpProcessDefinedStep = aValue;
}

inline G4double G4StepPoint::GetMass() const
{
  return fMass;
}

inline void G4StepPoint::SetMass(G4double value)
{
  fMass = value;
}

inline G4double G4StepPoint::GetCharge() const
{
  return fCharge;
}

inline void G4StepPoint::SetCharge(G4double value)
{
  fCharge = value;
}

inline G4double G4StepPoint::GetMagneticMoment() const
{
  return fMagneticMoment;
}

inline void G4StepPoint::SetMagneticMoment(G4double value)
{
  fMagneticMoment = value;
}

inline G4Material* G4StepPoint::GetMaterial() const
{
  return fpMaterial;
}

inline void G4StepPoint::SetMaterial(G4Material* material)
{
  fpMaterial = material;
}

inline const G4MaterialCutsCouple* G4StepPoint::GetMaterialCutsCouple() const
{
  return fpMaterialCutsCouple;
}

inline void G4StepPoint::SetMaterialCutsCouple(
  const G4MaterialCutsCouple* materialCutsCouple)
{
  fpMaterialCutsCouple = materialCutsCouple;
}

inline G4VSensitiveDetector* G4StepPoint::GetSensitiveDetector() const
{
  return fpSensitiveDetector;
}

inline void G4StepPoint::SetSensitiveDetector(G4VSensitiveDetector* aValue)
{
  fpSensitiveDetector = aValue;
}

inline void G4StepPoint::SetWeight(G4double aValue)
{
  fWeight = aValue;
}

inline G4double G4StepPoint::GetWeight() const
{
  return fWeight;
}
# 192 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4StepPoint.hh" 2 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TrackVector.hh" 1 3
# 41 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TrackVector.hh" 3
class G4Track;

using G4TrackVector = std::vector<G4Track*>;
# 56 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 1 3
# 43 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 1 3
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Globals.hh" 1 3
# 25 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Globals.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Types.hh" 1 3
# 26 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Globals.hh" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Utility.hh" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Utility.hh" 3
namespace PTL
{



template <typename... Args>
void
ConsumeParameters(Args&&...)
{}



template <typename Tp>
using EnvChoice = std::tuple<Tp, std::string, std::string>;



template <typename Tp>
using EnvChoiceList = std::set<EnvChoice<Tp>>;



class EnvSettings
{
public:
    using mutex_t = std::mutex;
    using string_t = std::string;
    using env_map_t = std::multimap<string_t, string_t>;
    using env_pair_t = std::pair<string_t, string_t>;

public:
    static EnvSettings* GetInstance()
    {
        static EnvSettings* _instance = new EnvSettings();
        return _instance;
    }

public:
    template <typename Tp>
    void insert(const std::string& env_id, Tp val)
    {
        std::stringstream ss;
        ss << std::boolalpha << val;
        m_mutex.lock();
        if(m_env.find(env_id) != m_env.end())
        {
            for(const auto& itr : m_env)
                if(itr.first == env_id && itr.second == ss.str())
                {
                    m_mutex.unlock();
                    return;
                }
        }
        m_env.insert(env_pair_t(env_id, ss.str()));
        m_mutex.unlock();
    }

    template <typename Tp>
    void insert(const std::string& env_id, EnvChoice<Tp> choice)
    {
        Tp& val = std::get<0>(choice);
        std::string& str_val = std::get<1>(choice);
        std::string& descript = std::get<2>(choice);

        std::stringstream ss, ss_long;
        ss << std::boolalpha << val;
        ss_long << std::boolalpha << std::setw(8) << std::left << val << " # (\""
                << str_val << "\") " << descript;
        m_mutex.lock();
        if(m_env.find(env_id) != m_env.end())
        {
            for(const auto& itr : m_env)
                if(itr.first == env_id && itr.second == ss.str())
                {
                    m_mutex.unlock();
                    return;
                }
        }
        m_env.insert(env_pair_t(env_id, ss_long.str()));
        m_mutex.unlock();
    }

    const env_map_t& get() const { return m_env; }
    mutex_t& mutex() const { return m_mutex; }

    friend std::ostream& operator<<(std::ostream& os, const EnvSettings& env)
    {
        std::stringstream filler;
        filler.fill('#');
        filler << std::setw(90) << "";
        std::stringstream ss;
        ss << filler.str() << "\n# Environment settings:\n";
        env.mutex().lock();
        for(const auto& itr : env.get())
        {
            ss << "# " << std::setw(35) << std::right << itr.first << "\t = \t"
               << std::left << itr.second << "\n";
        }
        env.mutex().unlock();
        ss << filler.str();
        os << ss.str() << std::endl;
        return os;
    }

private:
    env_map_t m_env;
    mutable mutex_t m_mutex;
};
# 153 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Utility.hh" 3
template <typename Tp>
Tp
GetEnv(const std::string& env_id, Tp _default = Tp())
{
    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string str_var = std::string(env_var);
        std::istringstream iss(str_var);
        Tp var = Tp();
        iss >> var;

        EnvSettings::GetInstance()->insert<Tp>(env_id, var);
        return var;
    }

    EnvSettings::GetInstance()->insert<Tp>(env_id, _default);


    return _default;
}




template <>
inline bool
GetEnv(const std::string& env_id, bool _default)
{
    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string var = std::string(env_var);
        bool val = true;
        if(var.find_first_not_of("0123456789") == std::string::npos)
            val = (bool) atoi(var.c_str());
        else
        {
            for(auto& itr : var)
                itr = (char)std::tolower(itr);
            if(var == "off" || var == "false")
                val = false;
        }

        EnvSettings::GetInstance()->insert<bool>(env_id, val);
        return val;
    }

    EnvSettings::GetInstance()->insert<bool>(env_id, false);


    return _default;
}




template <typename Tp>
Tp
GetEnv(const std::string& env_id, Tp _default, const std::string& msg)
{
    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string str_var = std::string(env_var);
        std::istringstream iss(str_var);
        Tp var = Tp();
        iss >> var;
        std::cout << "Environment variable \"" << env_id << "\" enabled with "
                  << "value == " << var << ". " << msg << std::endl;

        EnvSettings::GetInstance()->insert<Tp>(env_id, var);
        return var;
    }

    EnvSettings::GetInstance()->insert<Tp>(env_id, _default);


    return _default;
}
# 244 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Utility.hh" 3
template <typename Tp>
Tp
GetEnv(const std::string& env_id, const EnvChoiceList<Tp>& _choices, Tp _default)
{
    auto asupper = [](std::string var) {
        for(auto& itr : var)
            itr = (char)std::toupper(itr);
        return var;
    };

    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string str_var = std::string(env_var);
        std::string upp_var = asupper(str_var);
        Tp var = Tp();

        for(const auto& itr : _choices)
        {
            if(asupper(std::get<1>(itr)) == upp_var)
            {

                EnvSettings::GetInstance()->insert(env_id, itr);
                return std::get<0>(itr);
            }
        }
        std::istringstream iss(str_var);
        iss >> var;

        for(const auto& itr : _choices)
        {
            if(var == std::get<0>(itr))
            {

                EnvSettings::GetInstance()->insert(env_id, itr);
                return var;
            }
        }

        std::stringstream ss;
        ss << "\n### Environment setting error @ " << __FUNCTION__ << " (line "
           << 285 << ")! Invalid selection for \"" << env_id
           << "\". Valid choices are:\n";
        for(const auto& itr : _choices)
            ss << "\t\"" << std::get<0>(itr) << "\" or \"" << std::get<1>(itr) << "\" ("
               << std::get<2>(itr) << ")\n";
        std::cerr << ss.str() << std::endl;
        abort();
    }

    std::string _name = "???";
    std::string _desc = "description not provided";
    for(const auto& itr : _choices)
        if(std::get<0>(itr) == _default)
        {
            _name = std::get<1>(itr);
            _desc = std::get<2>(itr);
            break;
        }


    EnvSettings::GetInstance()->insert(env_id, EnvChoice<Tp>(_default, _name, _desc));


    return _default;
}



template <typename Tp>
Tp
GetChoice(const EnvChoiceList<Tp>& _choices, const std::string& str_var)
{
    auto asupper = [](std::string var) {
        for(auto& itr : var)
            itr = (char)std::toupper(itr);
        return var;
    };

    std::string upp_var = asupper(str_var);
    Tp var = Tp();

    for(const auto& itr : _choices)
    {
        if(asupper(std::get<1>(itr)) == upp_var)
        {

            return std::get<0>(itr);
        }
    }
    std::istringstream iss(str_var);
    iss >> var;

    for(const auto& itr : _choices)
    {
        if(var == std::get<0>(itr))
        {

            return var;
        }
    }

    std::stringstream ss;
    ss << "\n### Environment setting error @ " << __FUNCTION__ << " (line " << 347
       << ")! Invalid selection \"" << str_var << "\". Valid choices are:\n";
    for(const auto& itr : _choices)
        ss << "\t\"" << std::get<0>(itr) << "\" or \"" << std::get<1>(itr) << "\" ("
           << std::get<2>(itr) << ")\n";
    std::cerr << ss.str() << std::endl;
    abort();
}



inline void
PrintEnv(std::ostream& os = std::cout)
{
    os << (*EnvSettings::GetInstance());
}



struct ScopeDestructor
{
    template <typename FuncT>
    ScopeDestructor(FuncT&& _func)
    : m_functor(std::forward<FuncT>(_func))
    {}


    ScopeDestructor(const ScopeDestructor&) = delete;
    ScopeDestructor& operator=(const ScopeDestructor&) = delete;


    ScopeDestructor(ScopeDestructor&& rhs) noexcept
    : m_functor(std::move(rhs.m_functor))
    {
        rhs.m_functor = []() {};
    }

    ScopeDestructor& operator=(ScopeDestructor&& rhs) noexcept
    {
        if(this != &rhs)
        {
            m_functor = std::move(rhs.m_functor);
            rhs.m_functor = []() {};
        }
        return *this;
    }

    ~ScopeDestructor() { m_functor(); }

private:
    std::function<void()> m_functor = []() {};
};



}
# 29 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Globals.hh" 2 3
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/PTL/Globals.hh" 3
namespace PTL
{
template <typename T>
using decay_t = typename std::decay<T>::type;

template <bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;


namespace mpl
{


namespace impl
{



template <size_t... Indexes>
struct Index_tuple
{};


template <typename Itup1, typename Itup2>
struct Itup_cat;

template <size_t... Ind1, size_t... Ind2>
struct Itup_cat<Index_tuple<Ind1...>, Index_tuple<Ind2...>>
{
    using __type = Index_tuple<Ind1..., (Ind2 + sizeof...(Ind1))...>;
};


template <size_t NumT>
struct Build_index_tuple
: Itup_cat<typename Build_index_tuple<NumT / 2>::__type,
           typename Build_index_tuple<NumT - NumT / 2>::__type>
{};

template <>
struct Build_index_tuple<1>
{
    using __type = Index_tuple<0>;
};

template <>
struct Build_index_tuple<0>
{
    using __type = Index_tuple<>;
};


template <typename Tp, Tp... Idx>
struct integer_sequence
{
    using value_type = Tp;
    static constexpr size_t size() noexcept { return sizeof...(Idx); }
};

template <typename Tp, Tp NumT, typename ISeq = typename Build_index_tuple<NumT>::__type>
struct Make_integer_sequence;

template <typename Tp, Tp NumT, size_t... Idx>
struct Make_integer_sequence<Tp, NumT, Index_tuple<Idx...>>
{
    static_assert(NumT >= 0, "Cannot make integer sequence of negative length");

    using __type = integer_sequence<Tp, static_cast<Tp>(Idx)...>;
};


template <typename Tp, Tp NumT>
using make_integer_sequence = typename Make_integer_sequence<Tp, NumT>::__type;


template <size_t... Idx>
using index_sequence = integer_sequence<size_t, Idx...>;


template <size_t NumT>
using make_index_sequence = make_integer_sequence<size_t, NumT>;


template <typename... Types>
using index_sequence_for = make_index_sequence<sizeof...(Types)>;

template <size_t Idx, typename Tup>
using index_type_t = decay_t<decltype(std::get<Idx>(std::declval<Tup>()))>;

template <typename FnT, typename TupleT, size_t... Idx>
static inline auto
apply(FnT&& _func, TupleT _args, impl::index_sequence<Idx...>)
    -> decltype(std::forward<FnT>(_func)(std::get<Idx>(std::move(_args))...))
{


    if(sizeof...(Idx) == 0)
    {
        ConsumeParameters(_args);
    }

    return std::forward<FnT>(_func)(std::get<Idx>(std::move(_args))...);
}



}




template <size_t... Idx>
using index_sequence = impl::integer_sequence<size_t, Idx...>;


template <size_t NumT>
using make_index_sequence = impl::make_integer_sequence<size_t, NumT>;


template <typename... Types>
using index_sequence_for = impl::make_index_sequence<sizeof...(Types)>;

template <typename FnT, typename TupleT>
static inline void
apply(FnT&& _func, TupleT&& _args)
{
    using tuple_type = typename std::decay<TupleT>::type;
    constexpr auto N = std::tuple_size<tuple_type>::value;
    impl::apply(std::forward<FnT>(_func), std::forward<TupleT>(_args),
                impl::make_index_sequence<N>{});
}



}

}
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 2 3
# 67 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
template <typename... Types>
struct G4TypeList;



template <typename... Types>
struct G4CommonTypeList;



template <typename... Types>
struct G4TypeListSize;

template <typename... Types>
struct G4TypeListSize<G4TypeList<Types...>>
{
  static constexpr size_t value = sizeof...(Types);
};

template <typename... Types>
struct G4TypeListSize<std::tuple<Types...>>
{
  static constexpr size_t value = std::tuple_size<std::tuple<Types...>>::value;
};

namespace G4Impl
{
  template <typename Tp>
  std::string demangle()
  {



    return typeid(Tp).name();

  }

  template <typename... Tp>
  void consume_parameters(Tp&&...)
  {}


  template <typename RetT, typename... Tail>
  struct Functors;

  template <typename RetT, typename... Tail>
  struct Functors<RetT, G4TypeList<Tail...>>
  {
    using type = std::function<RetT(Tail...)>;
  };

  template <typename RetT, typename... CommonT, typename... Tail>
  struct Functors<RetT, G4CommonTypeList<CommonT...>, G4TypeList<Tail...>>
  {
    using type = std::function<RetT(CommonT..., Tail...)>;
  };

  template <typename RetT, typename... Types, typename... Tail>
  struct Functors<RetT, G4TypeList<G4TypeList<Types...>, Tail...>>
  {
    using type = std::tuple<std::function<RetT(Types...)>,
                            typename Functors<RetT, Tail>::type...>;
  };

  template <typename RetT, typename... CommonT, typename... Types,
            typename... Tail>
  struct Functors<RetT, G4CommonTypeList<CommonT...>,
                  G4TypeList<G4TypeList<Types...>, Tail...>>
  {
    using type = std::tuple<
      std::function<RetT(CommonT..., Types...)>,
      typename Functors<RetT, G4CommonTypeList<CommonT...>, Tail>::type...>;
  };

  template <typename RetT, typename... Tail>
  using Functors_t = typename Functors<RetT, Tail...>::type;

}




template <typename Type, typename FuncT, typename RetT = void>
struct FuncHandler
{
  using this_type = FuncHandler<Type, FuncT, RetT>;


  template <typename Tp>
  using decay_t = typename std::decay<Tp>::type;
  template <bool Bv, typename Tp = void>
  using enable_if_t = typename std::enable_if<Bv, Tp>::type;
  template <size_t... Idx>
  using index_sequence = PTL::mpl::index_sequence<Idx...>;
  template <size_t NumT>
  using make_index_sequence = PTL::mpl::make_index_sequence<NumT>;

  static constexpr size_t size = std::tuple_size<FuncT>::value;

  FuncHandler(FuncT& _functors)
    : m_functors(_functors)
  {}
# 180 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
  template <typename Func>
  void operator=(Func&& f)
  {
    assign(m_functors, std::forward<Func>(f), 0, make_index_sequence<size>{});
  }

 private:
  FuncT& m_functors;

  template <typename Tp>
  static enable_if_t<std::is_same<decay_t<Tp>, bool>::value, Tp>
  get_default_return_value()
  {
    return false;
  }

  template <typename Tp>
  static enable_if_t<std::is_same<decay_t<Tp>, std::string>::value, Tp>
  get_default_return_value()
  {


    return std::string("label-functor-not-set-for-") + G4Impl::demangle<Tp>();
  }

  template <typename Tp>
  static enable_if_t<std::is_pointer<decay_t<Tp>>::value, Tp>
  get_default_return_value()
  {
    return nullptr;
  }

 private:
  using return_t = decay_t<RetT>;
# 242 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
  template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
            enable_if_t<sizeof...(Tail) == 0, int> = 0>
  static auto invoke(Tp& _obj, int, index_sequence<Idx, Tail...>,
                     Args&&... _args)
    -> decltype(std::get<Idx>(_obj)(std::forward<Args>(_args)...), return_t{})
  {

    if(std::get<Idx>(_obj))
      return std::get<Idx>(_obj)(std::forward<Args>(_args)...);
    else
    {
      std::stringstream ss;
      ss << "Error! Functor "
         << G4Impl::demangle<decltype(std::get<Idx>(_obj))>()
         << " was not set for " << G4Impl::demangle<Type>();
      throw std::runtime_error(ss.str());
    }

    return get_default_return_value<return_t>();
  }
# 271 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
  template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
            enable_if_t<sizeof...(Tail) == 0, int> = 0>
  static auto invoke(Tp&, long, index_sequence<Idx, Tail...>, Args&&...)
    -> return_t
  {





    static_assert(!std::is_same<Tp, Tp>::value, "Error! No valid functor!");
    throw std::runtime_error(
      "Error! No valid functor! This should have caused a compilation error!");
    return return_t{};
  }
# 295 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
  template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
            enable_if_t<(sizeof...(Tail) > 0), int> = 0>
  static auto invoke(Tp& _obj, int, index_sequence<Idx, Tail...>,
                     Args&&... _args)
    -> decltype(std::get<Idx>(_obj)(std::forward<Args>(_args)...), return_t{})
  {
    return std::get<Idx>(_obj)(std::forward<Args>(_args)...);
  }
# 313 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.icc" 3
  template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
            enable_if_t<(sizeof...(Tail) > 0), int> = 0>
  static auto invoke(Tp& _obj, long, index_sequence<Idx, Tail...>,
                     Args&&... _args)
    -> decltype(invoke(_obj, 0, index_sequence<Tail...>{},
                       std::forward<Args>(_args)...))
  {
    return invoke(_obj, 0, index_sequence<Tail...>{},
                  std::forward<Args>(_args)...);
  }

 private:


  template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
            enable_if_t<sizeof...(Tail) == 0, int> = 0>
  static auto assign(LhsT& _lhs, RhsT&& _rhs, int, index_sequence<Idx, Tail...>)
    -> decltype((std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs)), void())
  {
    std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs);
  }



  template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
            enable_if_t<sizeof...(Tail) == 0, int> = 0>
  static void assign(LhsT&, RhsT&&, long, index_sequence<Idx, Tail...>)
  {





    static_assert(!std::is_same<LhsT, LhsT>::value,
                  "Error! No valid functor assignment!");
    throw std::runtime_error(
      "Error! No valid functor! This should have caused a compilation error!");
  }



  template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
            enable_if_t<(sizeof...(Tail) > 0), int> = 0>
  static auto assign(LhsT& _lhs, RhsT&& _rhs, int, index_sequence<Idx, Tail...>)
    -> decltype((std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs)), void())
  {
    std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs);
  }



  template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
            enable_if_t<(sizeof...(Tail) > 0), int> = 0>
  static void assign(LhsT& _lhs, RhsT&& _rhs, long,
                     index_sequence<Idx, Tail...>)
  {
    assign(_lhs, std::forward<RhsT>(_rhs), 0, index_sequence<Tail...>{});
  }

 public:





  template <typename... Args>
  auto operator()(Args&&... _args)
    -> decltype(std::declval<this_type>().invoke(std::declval<FuncT&>(), 0,
                                                 make_index_sequence<size>{},
                                                 std::forward<Args>(_args)...))
  {
    return invoke(m_functors, 0, make_index_sequence<size>{},
                  std::forward<Args>(_args)...);
  }
};
# 44 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 2 3
# 62 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 3
class G4Run;
class G4Event;
class G4Track;
class G4Step;

struct G4ProfileType
{
  enum : size_t
  {
    Run = 0,
    Event,
    Track,
    Step,
    User,
    TypeEnd
  };
};

struct G4ProfileOp
{
  enum : int
  {
    Query = 0,
    Label,
    Tool
  };
};



class G4Profiler
{
 public:
  using array_type = std::array<bool, G4ProfileType::TypeEnd>;




  struct ArgumentParser
  {
    explicit ArgumentParser(std::string) {}
  };


  static void Configure(const std::vector<std::string>& args);
  static void Configure(int argc, char** argv);
  static void Configure(ArgumentParser&, const std::vector<std::string>& args);
  static void Configure(ArgumentParser&, int argc, char** argv);
  static void Finalize();

  static bool GetEnabled(size_t v) { return GetEnabled().at(v); }
  static void SetEnabled(size_t v, bool val) { GetEnabled().at(v) = val; }

  static bool GetPerEvent() { return GetPerEventImpl(); }
  static void SetPerEvent(bool val) { GetPerEventImpl() = val; }

 private:
  static array_type& GetEnabled();
  static bool& GetPerEventImpl()
  {
    static bool _value = false;
    return _value;
  }
};




template <size_t Category>
struct G4ProfilerObject
{
  using type = void;
};

template <size_t Category>
using G4ProfilerObject_t = typename G4ProfilerObject<Category>::type;

template <>
struct G4ProfilerObject<G4ProfileType::Run>
{
  using type = const G4Run*;
};

template <>
struct G4ProfilerObject<G4ProfileType::Event>
{
  using type = const G4Event*;
};

template <>
struct G4ProfilerObject<G4ProfileType::Track>
{
  using type = const G4Track*;
};

template <>
struct G4ProfilerObject<G4ProfileType::Step>
{
  using type = const G4Step*;
};

template <>
struct G4ProfilerObject<G4ProfileType::User>
{
  using type = const std::string&;
};



template <size_t Category>
struct G4ProfilerArgs
{


  using value_type = G4ProfilerObject_t<Category>;



  using type = G4TypeList<G4TypeList<value_type> >;




};

template <size_t Category>
using G4ProfilerArgs_t = typename G4ProfilerArgs<Category>::type;



template <size_t Category, typename RetT, typename CommonT = G4CommonTypeList<>>
struct G4ProfilerFunctors
{
  using type = G4Impl::Functors_t<RetT, CommonT, G4ProfilerArgs_t<Category>>;
};

template <size_t Category, typename RetT, typename... CommonT>
using G4ProfilerFunctors_t =
  typename G4ProfilerFunctors<Category, RetT,
                              G4CommonTypeList<CommonT...>>::type;
# 246 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 3
namespace g4tim
{
  struct ProfilerArgparser
  {};


  template <typename... Types>
  struct handler
  {
    template <typename... Args>
    handler(Args&&...)
    {}
    ~handler() = default;
    handler(const handler&) = default;
    handler(handler&&) = default;
    handler& operator=(const handler&) = default;
    handler& operator=(handler&&) = default;

    void record() {}
    template <typename... Args>
    void start(Args&&...)
    {}
    template <typename... Args>
    void stop(Args&&...)
    {}
    void push() {}
    void pop() {}
    void reset() {}
    void report_at_exit(bool) {}
    template <typename... Args>
    void mark_begin(Args&&...)
    {}
    template <typename... Args>
    void mark_end(Args&&...)
    {}
    friend std::ostream& operator<<(std::ostream& os, const handler&)
    {
      return os;
    }
  };

  template <size_t Idx, typename Tp>
  struct user_bundle
  {
    template <typename... Args>
    user_bundle(Args&&...)
    {}

    template <typename... Types, typename... Args>
    static void configure(Args&&...)
    {}

    static void reset() {}
  };

}

using G4RunProfiler = g4tim::handler<>;
using G4EventProfiler = g4tim::handler<>;
using G4TrackProfiler = g4tim::handler<>;
using G4StepProfiler = g4tim::handler<>;
using G4UserProfiler = g4tim::handler<>;

template <typename... Types>
using G4ProfilerBundle = g4tim::handler<Types...>;
# 323 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 3
template <size_t Category>
class G4ProfilerConfig
{
 public:
  using type = G4ProfilerBundle<g4tim::user_bundle<Category, G4ProfileType>>;
  using this_type = G4ProfilerConfig<Category>;

  static constexpr size_t arg_sets =
    G4TypeListSize<G4ProfilerArgs_t<Category>>::value;

  using QueryFunc_t = G4ProfilerFunctors_t<Category, bool>;
  using LabelFunc_t = G4ProfilerFunctors_t<Category, std::string>;
  using ToolFunc_t = std::tuple<std::function<type*(const std::string&)>>;

 public:

  G4ProfilerConfig() = default;


  template <typename Arg, typename... Args>
  G4ProfilerConfig(Arg, Args...);


  ~G4ProfilerConfig();


  G4ProfilerConfig(G4ProfilerConfig&&) = default;
  G4ProfilerConfig& operator=(G4ProfilerConfig&&) = default;


  G4ProfilerConfig(const G4ProfilerConfig&) = delete;
  G4ProfilerConfig& operator=(const G4ProfilerConfig&) = delete;


  template <typename... Args>
  bool operator()(Args...);


  operator bool() const { return (m_bundle != nullptr); }

 private:
  type* m_bundle = nullptr;

  static QueryFunc_t& GetQueries()
  {
    static QueryFunc_t _value;
    return _value;
  }

  static LabelFunc_t& GetLables()
  {
    static LabelFunc_t _value;
    return _value;
  }

  static ToolFunc_t& GetTools()
  {
    static ToolFunc_t _value;
    return _value;
  }

 public:

  template <typename... Args>
  static bool Query(Args... _args);


  template <typename... Args>
  static std::string Label(Args... _args);


  template <typename... Args>
  static type* Tool(const std::string&);

  using QueryHandler_t = FuncHandler<this_type, QueryFunc_t, bool>;
  using LabelHandler_t = FuncHandler<this_type, LabelFunc_t, std::string>;
  using ToolHandler_t = FuncHandler<this_type, ToolFunc_t, type*>;

  static QueryHandler_t GetQueryFunctor();
  static QueryHandler_t GetFallbackQueryFunctor();

  static LabelHandler_t GetLabelFunctor();
  static LabelHandler_t GetFallbackLabelFunctor();

  static ToolHandler_t GetToolFunctor();
  static ToolHandler_t GetFallbackToolFunctor();

 private:
  template <bool B, typename Lhs, typename Rhs>
  using conditional_t = typename std::conditional<B, Lhs, Rhs>::type;


  template <int Idx>
  struct PersistentSettings
  {

    using functor_type = conditional_t<
      Idx == G4ProfileOp::Query, QueryFunc_t,
      conditional_t<Idx == G4ProfileOp::Label, LabelFunc_t, ToolFunc_t>>;

    PersistentSettings() = default;
    ~PersistentSettings() = default;

    functor_type m_functor;
  };

  template <int Idx>
  static PersistentSettings<Idx>& GetPersistentFallback();

  template <int Idx>
  static PersistentSettings<Idx>& GetPersistent();
};




template <size_t Category>
using G4ProfilerConfig_t = typename G4ProfilerConfig<Category>::type;



template <size_t Cat>
template <typename Arg, typename... Args>
G4ProfilerConfig<Cat>::G4ProfilerConfig(Arg _arg, Args... _args)
{
  this->operator()(_arg, _args...);
}



template <size_t Cat>
template <typename... Args>
bool G4ProfilerConfig<Cat>::operator()(Args... _args)
{
  if(Query(_args...))
  {
    m_bundle = Tool(Label(_args...));
    if(m_bundle)
      m_bundle->start(_args...);
    return (m_bundle != nullptr);
  }
  return false;
}




template <size_t Cat>
template <typename... Args>
bool G4ProfilerConfig<Cat>::Query(Args... _args)
{
  return QueryHandler_t{ GetPersistent<G4ProfileOp::Query>().m_functor }(
    _args...);
}




template <size_t Cat>
template <typename... Args>
std::string G4ProfilerConfig<Cat>::Label(Args... _args)
{
  return LabelHandler_t{ GetPersistent<G4ProfileOp::Label>().m_functor }(
    _args...);
}




template <size_t Cat>
template <typename... Args>
typename G4ProfilerConfig<Cat>::type* G4ProfilerConfig<Cat>::Tool(
  const std::string& _args)
{
  return ToolHandler_t{ GetPersistent<G4ProfileOp::Tool>().m_functor }(_args);
}
# 508 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Profiler.hh" 3
extern template class G4ProfilerConfig<G4ProfileType::Run>;
extern template class G4ProfilerConfig<G4ProfileType::Event>;
extern template class G4ProfilerConfig<G4ProfileType::Track>;
extern template class G4ProfilerConfig<G4ProfileType::Step>;
extern template class G4ProfilerConfig<G4ProfileType::User>;
extern template G4ProfilerConfig<G4ProfileType::Run>::G4ProfilerConfig(const G4Run*);
extern template G4ProfilerConfig<G4ProfileType::Event>::G4ProfilerConfig(const G4Event*);
extern template G4ProfilerConfig<G4ProfileType::Track>::G4ProfilerConfig(const G4Track*);
extern template G4ProfilerConfig<G4ProfileType::Step>::G4ProfilerConfig(const G4Step*);
extern template G4ProfilerConfig<G4ProfileType::User>::G4ProfilerConfig(const std::string&);
# 57 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3

class G4Polyline;
class G4Track;

class G4Step
{
  public:

   using ProfilerConfig = G4ProfilerConfig<G4ProfileType::Step>;

    G4Step();
   ~G4Step();


    G4Step(const G4Step&);
    G4Step& operator=(const G4Step&);


    G4Track* GetTrack() const;
    void SetTrack(G4Track* value);


    G4StepPoint* GetPreStepPoint() const;
    void SetPreStepPoint(G4StepPoint* value);
    G4StepPoint* ResetPreStepPoint(G4StepPoint* value=nullptr);






    G4StepPoint* GetPostStepPoint() const;
    void SetPostStepPoint(G4StepPoint* value);
    G4StepPoint* ResetPostStepPoint(G4StepPoint* value=nullptr);






    G4double GetStepLength() const;
    void SetStepLength(G4double value);





    G4double GetTotalEnergyDeposit() const;
    void SetTotalEnergyDeposit(G4double value);


    G4double GetNonIonizingEnergyDeposit() const;
    void SetNonIonizingEnergyDeposit(G4double value);


    G4SteppingControl GetControlFlag() const;
    void SetControlFlag(G4SteppingControl StepControlFlag);


    void AddTotalEnergyDeposit(G4double value);
    void ResetTotalEnergyDeposit();


    void AddNonIonizingEnergyDeposit(G4double value);
    void ResetNonIonizingEnergyDeposit();


    G4bool IsFirstStepInVolume() const;
    G4bool IsLastStepInVolume() const;

    void SetFirstStepFlag();
    void ClearFirstStepFlag();
    void SetLastStepFlag();
    void ClearLastStepFlag();



    G4ThreeVector GetDeltaPosition() const;
    G4double GetDeltaTime() const;


    G4ThreeVector GetDeltaMomentum() const;
    G4double GetDeltaEnergy() const;



    void InitializeStep(G4Track* aValue);


    void UpdateTrack();


    void CopyPostToPreStepPoint();


    G4Polyline* CreatePolyline() const;


    inline void SetPointerToVectorOfAuxiliaryPoints(std::vector<G4ThreeVector>* vec);
    inline std::vector<G4ThreeVector>* GetPointerToVectorOfAuxiliaryPoints() const;




    std::size_t GetNumberOfSecondariesInCurrentStep() const;


    const std::vector<const G4Track*>* GetSecondaryInCurrentStep() const;

    const G4TrackVector* GetSecondary() const;
    G4TrackVector* GetfSecondary();
    G4TrackVector* NewSecondaryVector();






    void DeleteSecondaryVector();



    void SetSecondary(G4TrackVector* value);


  protected:

    G4double fTotalEnergyDeposit = 0.0;


    G4double fNonIonizingEnergyDeposit = 0.0;


  private:

    G4StepPoint* fpPreStepPoint = nullptr;
    G4StepPoint* fpPostStepPoint = nullptr;
    G4double fStepLength = 0.0;



    G4Track* fpTrack = nullptr;

    G4SteppingControl fpSteppingControlFlag = NormalCondition;


    G4bool fFirstStepInVolume = false;
    G4bool fLastStepInVolume = false;


    G4TrackVector* fSecondary = nullptr;


    std::size_t nSecondaryByLastStep = 0;


    std::vector<const G4Track*>* secondaryInCurrentStep = nullptr;

    std::vector<G4ThreeVector>* fpVectorOfAuxiliaryPointsPointer = nullptr;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.icc" 1 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.icc" 3
inline G4StepPoint* G4Step::GetPreStepPoint() const
{
  return fpPreStepPoint;
}

inline void G4Step::SetPreStepPoint(G4StepPoint* value)
{
  delete fpPreStepPoint;
  fpPreStepPoint = value;
}

inline G4StepPoint* G4Step::ResetPreStepPoint(G4StepPoint* value)
{
  G4StepPoint* previousSP = fpPreStepPoint;
  fpPreStepPoint = value;
  return previousSP;
}

inline G4StepPoint* G4Step::GetPostStepPoint() const
{
  return fpPostStepPoint;
}

inline void G4Step::SetPostStepPoint(G4StepPoint* value)
{
  delete fpPostStepPoint;
  fpPostStepPoint = value;
}

inline G4StepPoint* G4Step::ResetPostStepPoint(G4StepPoint* value)
{
  G4StepPoint* previousSP = fpPostStepPoint;
  fpPostStepPoint = value;
  return previousSP;
}

inline G4double G4Step::GetStepLength() const
{
  return fStepLength;
}

inline void G4Step::SetStepLength(G4double value)
{
  fStepLength = value;
}

inline G4ThreeVector G4Step::GetDeltaPosition() const
{
  return fpPostStepPoint->GetPosition() - fpPreStepPoint->GetPosition();
}

inline G4double G4Step::GetDeltaTime() const
{
  return fpPostStepPoint->GetLocalTime() - fpPreStepPoint->GetLocalTime();
}

inline G4double G4Step::GetTotalEnergyDeposit() const
{
  return fTotalEnergyDeposit;
}

inline void G4Step::SetTotalEnergyDeposit(G4double value)
{
  fTotalEnergyDeposit = value;
}

inline G4double G4Step::GetNonIonizingEnergyDeposit() const
{
  return fNonIonizingEnergyDeposit;
}

inline void G4Step::SetNonIonizingEnergyDeposit(G4double value)
{
  fNonIonizingEnergyDeposit = value;
}

inline void G4Step::AddTotalEnergyDeposit(G4double value)
{
  fTotalEnergyDeposit += value;
}

inline void G4Step::ResetTotalEnergyDeposit()
{
  fTotalEnergyDeposit = 0.;
  fNonIonizingEnergyDeposit = 0.;
}

inline void G4Step::AddNonIonizingEnergyDeposit(G4double value)
{
  fNonIonizingEnergyDeposit += value;
}

inline void G4Step::ResetNonIonizingEnergyDeposit()
{
  fNonIonizingEnergyDeposit = 0.;
}

inline void G4Step::SetControlFlag(G4SteppingControl value)
{
  fpSteppingControlFlag = value;
}

inline G4SteppingControl G4Step::GetControlFlag() const
{
  return fpSteppingControlFlag;
}

inline void G4Step::CopyPostToPreStepPoint()
{

  *(fpPreStepPoint) = *(fpPostStepPoint);
  fpPostStepPoint->SetStepStatus(fUndefined);


  nSecondaryByLastStep = fSecondary->size();
}






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/trkdefs.hh" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 2 3




# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 1 3
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElectronOccupancy.hh" 1 3
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElectronOccupancy.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/pwdefs.hh" 1 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ElectronOccupancy.hh" 2 3

class G4ElectronOccupancy
{
  public:
    enum
    {
      MaxSizeOfOrbit = 20
    };

    G4ElectronOccupancy(G4int sizeOrbit = MaxSizeOfOrbit);
    G4ElectronOccupancy(const G4ElectronOccupancy& right);

    virtual ~G4ElectronOccupancy();


    inline void* operator new(size_t);
    inline void operator delete(void* aElectronOccupancy);

    G4ElectronOccupancy& operator=(const G4ElectronOccupancy& right);
    G4bool operator==(const G4ElectronOccupancy& right) const;
    G4bool operator!=(const G4ElectronOccupancy& right) const;

    inline G4int GetTotalOccupancy() const;
    inline G4int GetOccupancy(G4int orbit) const;




    G4int AddElectron(G4int orbit, G4int number = 1);
    G4int RemoveElectron(G4int orbit, G4int number = 1);

    inline G4int GetSizeOfOrbit() const;
    void DumpInfo() const;

  private:
    G4int theSizeOfOrbit = 0;
    G4int theTotalOccupancy = 0;
    G4int* theOccupancies = nullptr;
};

extern G4Allocator<G4ElectronOccupancy>*& aElectronOccupancyAllocator();





inline void* G4ElectronOccupancy::operator new(size_t)
{
  if (aElectronOccupancyAllocator() == nullptr) {
    aElectronOccupancyAllocator() = new G4Allocator<G4ElectronOccupancy>;
  }
  return (void*)aElectronOccupancyAllocator()->MallocSingle();
}

inline void G4ElectronOccupancy::operator delete(void* aElectronOccupancy)
{
  aElectronOccupancyAllocator()->FreeSingle((G4ElectronOccupancy*)aElectronOccupancy);
}

inline G4int G4ElectronOccupancy::GetSizeOfOrbit() const
{
  return theSizeOfOrbit;
}

inline G4int G4ElectronOccupancy::GetTotalOccupancy() const
{
  return theTotalOccupancy;
}

inline G4int G4ElectronOccupancy::GetOccupancy(G4int orbit) const
{
  G4int value = 0;
  if ((orbit >= 0) && (orbit < theSizeOfOrbit)) {
    value = theOccupancies[orbit];
  }
  return value;
}
# 47 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LorentzVector.hh" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4LorentzVector.hh" 3
using G4LorentzVector = CLHEP::HepLorentzVector;
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PDefManager.hh" 1 3
# 64 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PDefManager.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stdlib.h" 1 3
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/stdlib.h" 3
using std::abort;
using std::atexit;
using std::exit;


  using std::at_quick_exit;


  using std::quick_exit;


  using std::_Exit;




using std::div_t;
using std::ldiv_t;

using std::abs;
using std::atof;
using std::atoi;
using std::atol;
using std::bsearch;
using std::calloc;
using std::div;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::malloc;

using std::mblen;
using std::mbstowcs;
using std::mbtowc;

using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;

using std::wcstombs;
using std::wctomb;
# 65 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PDefManager.hh" 2 3

class G4ProcessManager;
class G4VTrackingManager;

class G4PDefData
{




  public:
    void initialize();

    G4ProcessManager* theProcessManager = nullptr;
    G4VTrackingManager* theTrackingManager = nullptr;
};

class G4PDefManager
{
  public:
    G4PDefManager();




    G4int CreateSubInstance();




    void NewSubInstances();


    void FreeSlave();

    G4PDefData* GetOffset();

    void UseWorkArea(G4PDefData* newOffset);

    G4PDefData* FreeWorkArea();

               static G4int& slavetotalspace();
               static G4PDefData*& offset();

  private:
    G4int totalobj{0};
    G4Mutex mutex;
};
# 46 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 2 3







class G4ProcessManager;
class G4DecayTable;
class G4ParticleTable;
class G4ParticlePropertyTable;
class G4VTrackingManager;

using G4ParticleDefinitionSubInstanceManager = G4PDefManager;

class G4ParticleDefinition
{
    friend class G4ParticlePropertyTable;

  public:
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 3
    G4ParticleDefinition(const G4String& aName, G4double mass, G4double width, G4double charge,
                         G4int iSpin, G4int iParity, G4int iConjugation, G4int iIsospin,
                         G4int iIsospinZ, G4int gParity, const G4String& pType, G4int lepton,
                         G4int baryon, G4int encoding, G4bool stable, G4double lifetime,
                         G4DecayTable* decaytable, G4bool shortlived = false,
                         const G4String& subType = "", G4int anti_encoding = 0,
                         G4double magneticMoment = 0.0);


    virtual ~G4ParticleDefinition();


    G4ParticleDefinition(const G4ParticleDefinition&) = delete;
    G4ParticleDefinition& operator=(const G4ParticleDefinition&) = delete;

    G4bool operator==(const G4ParticleDefinition& right) const;
    G4bool operator!=(const G4ParticleDefinition& right) const;




    const G4String& GetParticleName() const { return theParticleName; }

    G4double GetPDGMass() const { return thePDGMass; }
    G4double GetPDGWidth() const { return thePDGWidth; }
    G4double GetPDGCharge() const { return thePDGCharge; }

    G4double GetPDGSpin() const { return thePDGSpin; }
    G4int GetPDGiSpin() const { return thePDGiSpin; }
    G4int GetPDGiParity() const { return thePDGiParity; }
    G4int GetPDGiConjugation() const { return thePDGiConjugation; }
    G4double GetPDGIsospin() const { return thePDGIsospin; }
    G4double GetPDGIsospin3() const { return thePDGIsospin3; }
    G4int GetPDGiIsospin() const { return thePDGiIsospin; }
    G4int GetPDGiIsospin3() const { return thePDGiIsospin3; }
    G4int GetPDGiGParity() const { return thePDGiGParity; }

    G4double GetPDGMagneticMoment() const { return thePDGMagneticMoment; }
    inline void SetPDGMagneticMoment(G4double mageticMoment);


    G4double CalculateAnomaly() const;

    const G4String& GetParticleType() const { return theParticleType; }
    const G4String& GetParticleSubType() const { return theParticleSubType; }
    G4int GetLeptonNumber() const { return theLeptonNumber; }
    G4int GetBaryonNumber() const { return theBaryonNumber; }

    G4int GetPDGEncoding() const { return thePDGEncoding; }
    G4int GetAntiPDGEncoding() const { return theAntiPDGEncoding; }
    inline void SetAntiPDGEncoding(G4int aEncoding);




    inline G4int GetQuarkContent(G4int flavor) const;
    inline G4int GetAntiQuarkContent(G4int flavor) const;

    G4bool IsShortLived() const { return fShortLivedFlag; }

    inline G4bool GetPDGStable() const;
    void SetPDGStable(const G4bool aFlag) { thePDGStable = aFlag; }

    inline G4double GetPDGLifeTime() const;
    void SetPDGLifeTime(G4double aLifeTime) { thePDGLifeTime = aLifeTime; }


    inline G4double GetIonLifeTime() const;



    inline G4DecayTable* GetDecayTable() const;
    inline void SetDecayTable(G4DecayTable* aDecayTable);



    G4ProcessManager* GetProcessManager() const;
    void SetProcessManager(G4ProcessManager* aProcessManager);



    G4VTrackingManager* GetTrackingManager() const;
    void SetTrackingManager(G4VTrackingManager* aTrackingManager);


    inline G4ParticleTable* GetParticleTable() const;



    inline G4int GetAtomicNumber() const;
    inline G4int GetAtomicMass() const;


    void DumpTable() const;





    inline void SetVerboseLevel(G4int value);
    inline G4int GetVerboseLevel() const;

    void SetApplyCutsFlag(G4bool);
    inline G4bool GetApplyCutsFlag() const;



    inline G4bool IsGeneralIon() const;



    inline G4bool IsMuonicAtom() const;


    inline G4ProcessManager* GetMasterProcessManager() const;


    inline void SetMasterProcessManager(G4ProcessManager* aNewPM);


    inline G4int GetInstanceID() const;


    static const G4PDefManager& GetSubInstanceManager();


    static void Clean();

    void SetParticleDefinitionID(G4int id = -1);
    inline G4int GetParticleDefinitionID() const;
# 216 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 3
    inline G4bool IsHypernucleus() const;
    inline G4int GetNumberOfLambdasInHypernucleus() const;
    inline G4bool IsAntiHypernucleus() const;
    inline G4int GetNumberOfAntiLambdasInAntiHypernucleus() const;

  protected:

    G4ParticleDefinition();





    G4int FillQuarkContents();

    inline void SetParticleSubType(const G4String& subtype);

    inline void SetAtomicNumber(G4int);
    inline void SetAtomicMass(G4int);

    enum
    {
      NumberOfQuarkFlavor = 6
    };




    G4int theQuarkContent[NumberOfQuarkFlavor];
    G4int theAntiQuarkContent[NumberOfQuarkFlavor];

    G4bool isGeneralIon = false;
    G4bool isMuonicAtom = false;

  private:




    G4ProcessManager* theProcessManagerShadow = nullptr;


    G4int g4particleDefinitionInstanceID = 0;


               static G4PDefManager subInstanceManager;






    G4String theParticleName = "";




    G4double thePDGMass = 0.0;




    G4double thePDGWidth = 0.0;


    G4double thePDGCharge = 0.0;







    G4int thePDGiSpin = 0;


    G4double thePDGSpin = 0.0;



    G4int thePDGiParity = 0;


    G4int thePDGiConjugation = 0;


    G4int thePDGiGParity = 0;


    G4int thePDGiIsospin = 0;
    G4int thePDGiIsospin3 = 0;


    G4double thePDGIsospin = 0.0;
    G4double thePDGIsospin3 = 0.0;


    G4double thePDGMagneticMoment = 0.0;


    G4int theLeptonNumber = 0;


    G4int theBaryonNumber = 0;


    G4String theParticleType = "";



    G4String theParticleSubType = "";


    G4int thePDGEncoding = 0;


    G4int theAntiPDGEncoding = 0;





    G4bool fShortLivedFlag = false;




    G4bool thePDGStable = false;



    G4double thePDGLifeTime = 0.0;


    G4DecayTable* theDecayTable = nullptr;

    G4ParticleTable* theParticleTable = nullptr;

    G4int theAtomicNumber = 0;
    G4int theAtomicMass = 0;

    G4int verboseLevel = 1;
    G4bool fApplyCutsFlag = false;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.icc" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.icc" 3
inline G4int G4ParticleDefinition::GetInstanceID() const
{
  return g4particleDefinitionInstanceID;
}

inline G4bool G4ParticleDefinition::GetPDGStable() const
{
  if (IsGeneralIon()) {
    return (GetIonLifeTime() < 0.);
  }

  return thePDGStable;
}

inline G4double G4ParticleDefinition::GetPDGLifeTime() const
{
  return thePDGLifeTime;
}

inline G4double G4ParticleDefinition::GetIonLifeTime() const
{



  return thePDGLifeTime;
}

inline G4ParticleTable* G4ParticleDefinition::GetParticleTable() const
{
  return theParticleTable;
}

inline G4DecayTable* G4ParticleDefinition::GetDecayTable() const
{
  return theDecayTable;
}

inline void G4ParticleDefinition::SetDecayTable(G4DecayTable* aDecayTable)
{
  theDecayTable = aDecayTable;
}

inline void G4ParticleDefinition::SetVerboseLevel(G4int value)
{
  verboseLevel = value;
}

inline G4int G4ParticleDefinition::GetVerboseLevel() const
{
  return verboseLevel;
}

inline G4ProcessManager* G4ParticleDefinition::GetMasterProcessManager() const
{
  return theProcessManagerShadow;
}

inline void G4ParticleDefinition::SetMasterProcessManager(G4ProcessManager* aNewPM)
{
  theProcessManagerShadow = aNewPM;
}

inline G4int G4ParticleDefinition::GetQuarkContent(G4int flavor) const
{
  G4int content = 0;
  if ((flavor > 0) && (flavor <= NumberOfQuarkFlavor)) {
    content = theQuarkContent[flavor - 1];
  }
  else {







  }
  return content;
}

inline G4int G4ParticleDefinition::GetAntiQuarkContent(G4int flavor) const
{
  G4int content = 0;
  if ((flavor > 0) && (flavor <= NumberOfQuarkFlavor)) {
    content = theAntiQuarkContent[flavor - 1];
  }
  else {
# 127 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.icc" 3
  }
  return content;
}

inline void G4ParticleDefinition::SetParticleSubType(const G4String& subtype)
{
  theParticleSubType = subtype;
}

inline void G4ParticleDefinition::SetAntiPDGEncoding(G4int aEncoding)
{
  theAntiPDGEncoding = aEncoding;
}

inline G4bool G4ParticleDefinition::GetApplyCutsFlag() const
{
  return fApplyCutsFlag;
}

inline void G4ParticleDefinition::SetAtomicNumber(G4int i)
{
  theAtomicNumber = i;
}

inline G4int G4ParticleDefinition::GetAtomicNumber() const
{
  return theAtomicNumber;
}

inline void G4ParticleDefinition::SetAtomicMass(G4int i)
{
  theAtomicMass = i;
}

inline G4int G4ParticleDefinition::GetAtomicMass() const
{
  return theAtomicMass;
}

inline void G4ParticleDefinition::SetPDGMagneticMoment(G4double magneticMoment)
{
  thePDGMagneticMoment = magneticMoment;
}

inline G4bool G4ParticleDefinition::IsGeneralIon() const
{
  return isGeneralIon;
}

inline G4bool G4ParticleDefinition::IsMuonicAtom() const
{
  return isMuonicAtom;
}

inline G4int G4ParticleDefinition::GetParticleDefinitionID() const
{
  return g4particleDefinitionInstanceID;
}

inline G4bool G4ParticleDefinition::IsHypernucleus() const
{
  return GetNumberOfLambdasInHypernucleus() > 0;
}

inline G4int G4ParticleDefinition::GetNumberOfLambdasInHypernucleus() const
{
  G4int numberOfLambdas = 0;

  if (thePDGEncoding > 0 && thePDGEncoding / 1000000000 != 0) {
    numberOfLambdas = (thePDGEncoding / 10000000) % 100;
  }
  return numberOfLambdas;
}

inline G4bool G4ParticleDefinition::IsAntiHypernucleus() const
{
  return GetNumberOfAntiLambdasInAntiHypernucleus() > 0;
}

inline G4int G4ParticleDefinition::GetNumberOfAntiLambdasInAntiHypernucleus() const
{
  G4int numberOfAntiLambdas = 0;

  if (thePDGEncoding < 0 && thePDGEncoding / 1000000000 != 0) {
    numberOfAntiLambdas = (std::abs(thePDGEncoding) / 10000000) % 100;
  }
  return numberOfAntiLambdas;
}
# 362 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleDefinition.hh" 2 3
# 50 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleMomentum.hh" 1 3
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4ParticleMomentum.hh" 3
using G4ParticleMomentum = G4ThreeVector;
# 51 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 2 3








class G4PrimaryParticle;
class G4DecayProducts;

class G4DynamicParticle
{
  public:

    G4DynamicParticle();

    G4DynamicParticle(const G4ParticleDefinition* aParticleDefinition,
                      const G4ThreeVector& aMomentumDirection, G4double aKineticEnergy);
    G4DynamicParticle(const G4ParticleDefinition* aParticleDefinition,
                      const G4ThreeVector& aParticleMomentum);
    G4DynamicParticle(const G4ParticleDefinition* aParticleDefinition,
                      const G4LorentzVector& aParticleMomentum);
    G4DynamicParticle(const G4ParticleDefinition* aParticleDefinition, G4double aTotalEnergy,
                      const G4ThreeVector& aParticleMomentum);
    G4DynamicParticle(const G4ParticleDefinition* aParticleDefinition,
                      const G4ThreeVector& aMomentumDirection, G4double aKineticEnergy,
                      const G4double dynamicalMass);

    G4DynamicParticle(const G4DynamicParticle& right);


    ~G4DynamicParticle();


    G4DynamicParticle& operator=(const G4DynamicParticle& right);
    G4bool operator==(const G4DynamicParticle& right) const;
    G4bool operator!=(const G4DynamicParticle& right) const;


    G4DynamicParticle(G4DynamicParticle&& from);
    G4DynamicParticle& operator=(G4DynamicParticle&& from);


    inline void* operator new(size_t);
    inline void operator delete(void* aDynamicParticle);




    inline const G4ThreeVector& GetMomentumDirection() const;


    inline void SetMomentumDirection(const G4ThreeVector& aDirection);


    inline void SetMomentumDirection(G4double px, G4double py, G4double pz);


    inline G4ThreeVector GetMomentum() const;


    void SetMomentum(const G4ThreeVector& momentum);


    inline G4LorentzVector Get4Momentum() const;


    void Set4Momentum(const G4LorentzVector& momentum);


    inline G4double GetTotalMomentum() const;


    inline G4double GetTotalEnergy() const;


    inline G4double GetKineticEnergy() const;




    inline G4double GetLogKineticEnergy() const;


    inline void SetKineticEnergy(G4double aEnergy);


    inline G4double GetBeta() const;


    inline G4double GetProperTime() const;


    inline void SetProperTime(G4double);


    inline const G4ThreeVector& GetPolarization() const;
    inline void SetPolarization(const G4ThreeVector&);
    inline void SetPolarization(G4double polX, G4double polY, G4double polZ);



    inline G4double GetMass() const;
    inline void SetMass(G4double mass);



    inline G4double GetCharge() const;
    inline void SetCharge(G4double charge);
    inline void SetCharge(G4int chargeInUnitOfEplus);



    inline G4double GetSpin() const;
    inline void SetSpin(G4double spin);
    inline void SetSpin(G4int spinInUnitOfHalfInteger);



    inline G4double GetMagneticMoment() const;
    inline void SetMagneticMoment(G4double magneticMoment);



    inline const G4ElectronOccupancy* GetElectronOccupancy() const;
    inline G4int GetTotalOccupancy() const;
    inline G4int GetOccupancy(G4int orbit) const;
    inline void AddElectron(G4int orbit, G4int number = 1);
    inline void RemoveElectron(G4int orbit, G4int number = 1);


    inline const G4ParticleDefinition* GetParticleDefinition() const;
    void SetDefinition(const G4ParticleDefinition* aParticleDefinition);



    inline G4ParticleDefinition* GetDefinition() const;


    inline const G4DecayProducts* GetPreAssignedDecayProducts() const;
    inline void SetPreAssignedDecayProducts(G4DecayProducts* aDecayProducts);


    inline G4double GetPreAssignedDecayProperTime() const;
    inline void SetPreAssignedDecayProperTime(G4double);




    void DumpInfo(G4int mode = 0) const;





    inline void SetVerboseLevel(G4int value);
    inline G4int GetVerboseLevel() const;

    inline void SetPrimaryParticle(G4PrimaryParticle* p);
    inline void SetPDGcode(G4int c);




    inline G4PrimaryParticle* GetPrimaryParticle() const;







    inline G4int GetPDGcode() const;

  protected:
    void AllocateElectronOccupancy();
    G4double GetElectronMass() const;

  private:
    inline void ComputeBeta() const;


    G4ThreeVector theMomentumDirection;

    G4ThreeVector thePolarization;


    const G4ParticleDefinition* theParticleDefinition = nullptr;

    G4ElectronOccupancy* theElectronOccupancy = nullptr;

    G4DecayProducts* thePreAssignedDecayProducts = nullptr;




    G4PrimaryParticle* primaryParticle = nullptr;

    G4double theKineticEnergy = 0.0;

    mutable G4double theLogKineticEnergy = std::numeric_limits<double>::max();

    mutable G4double theBeta = -1.0;

    G4double theProperTime = 0.0;

    G4double theDynamicalMass = 0.0;

    G4double theDynamicalCharge = 0.0;

    G4double theDynamicalSpin = 0.0;

    G4double theDynamicalMagneticMoment = 0.0;

    G4double thePreAssignedDecayTime = -1.0;

    G4int verboseLevel = 1;

    G4int thePDGcode = 0;
};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.icc" 1 3
# 31 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.icc" 3
extern G4Allocator<G4DynamicParticle>*& pDynamicParticleAllocator();





inline void* G4DynamicParticle::operator new(size_t)
{
  if (pDynamicParticleAllocator() == nullptr) {
    pDynamicParticleAllocator() = new G4Allocator<G4DynamicParticle>;
  }
  return pDynamicParticleAllocator()->MallocSingle();
}

inline void G4DynamicParticle::operator delete(void* aDynamicParticle)
{
  pDynamicParticleAllocator()->FreeSingle((G4DynamicParticle*)aDynamicParticle);
}





inline const G4ElectronOccupancy* G4DynamicParticle::GetElectronOccupancy() const
{
  return theElectronOccupancy;
}

inline G4int G4DynamicParticle::GetTotalOccupancy() const
{
  return (theElectronOccupancy) != nullptr ? theElectronOccupancy->GetTotalOccupancy() : 0;
}

inline G4int G4DynamicParticle::GetOccupancy(G4int orbit) const
{
  return (theElectronOccupancy) != nullptr ? theElectronOccupancy->GetOccupancy(orbit) : 0;
}

inline void G4DynamicParticle::AddElectron(G4int orbit, G4int number)
{
  if (theElectronOccupancy == nullptr) {
    AllocateElectronOccupancy();
  }
  if (theElectronOccupancy != nullptr) {
    G4int n = theElectronOccupancy->AddElectron(orbit, number);
    theDynamicalCharge -= CLHEP::eplus * n;
    theDynamicalMass += CLHEP::electron_mass_c2 * n;
  }
}

inline void G4DynamicParticle::RemoveElectron(G4int orbit, G4int number)
{
  if (theElectronOccupancy == nullptr) {
    AllocateElectronOccupancy();
  }
  if (theElectronOccupancy != nullptr) {
    G4int n = theElectronOccupancy->RemoveElectron(orbit, number);
    theDynamicalCharge += CLHEP::eplus * n;
    theDynamicalMass -= CLHEP::electron_mass_c2 * n;
  }
}

inline G4double G4DynamicParticle::GetCharge() const
{
  return theDynamicalCharge;
}

inline void G4DynamicParticle::SetCharge(G4double newCharge)
{
  theDynamicalCharge = newCharge;
}

inline void G4DynamicParticle::SetCharge(G4int newCharge)
{
  theDynamicalCharge = newCharge * CLHEP::eplus;
}

inline G4double G4DynamicParticle::GetMass() const
{
  return theDynamicalMass;
}

inline void G4DynamicParticle::SetMass(G4double newMass)
{
  if (theDynamicalMass != newMass) {
    theDynamicalMass = std::max(newMass, 0.0);
    theBeta = -1.0;
  }
}

inline G4double G4DynamicParticle::GetSpin() const
{
  return theDynamicalSpin;
}

inline void G4DynamicParticle::SetSpin(G4double spin)
{
  theDynamicalSpin = spin;
}

inline void G4DynamicParticle::SetSpin(G4int spinInUnitOfHalfInteger)
{
  theDynamicalSpin = spinInUnitOfHalfInteger * 0.5;
}

inline G4double G4DynamicParticle::GetMagneticMoment() const
{
  return theDynamicalMagneticMoment;
}

inline void G4DynamicParticle::SetMagneticMoment(G4double magneticMoment)
{
  theDynamicalMagneticMoment = magneticMoment;
}

inline const G4ThreeVector& G4DynamicParticle::GetMomentumDirection() const
{
  return theMomentumDirection;
}

inline G4ThreeVector G4DynamicParticle::GetMomentum() const
{
  G4double pModule =
    std::sqrt(theKineticEnergy * theKineticEnergy + 2 * theKineticEnergy * theDynamicalMass);
  G4ThreeVector pMomentum(theMomentumDirection.x() * pModule, theMomentumDirection.y() * pModule,
                          theMomentumDirection.z() * pModule);
  return pMomentum;
}

inline G4LorentzVector G4DynamicParticle::Get4Momentum() const
{
  const G4double mass = theDynamicalMass;
  const G4double energy = theKineticEnergy;
  const G4double momentum = std::sqrt(energy * energy + 2.0 * mass * energy);
  G4LorentzVector p4(theMomentumDirection.x() * momentum, theMomentumDirection.y() * momentum,
                     theMomentumDirection.z() * momentum, energy + mass);
  return p4;
}

inline G4double G4DynamicParticle::GetTotalMomentum() const
{


  return std::sqrt((theKineticEnergy + 2. * theDynamicalMass) * theKineticEnergy);
}

inline G4ParticleDefinition* G4DynamicParticle::GetDefinition() const
{
  return const_cast<G4ParticleDefinition*>(theParticleDefinition);
}

inline const G4ParticleDefinition* G4DynamicParticle::GetParticleDefinition() const
{
  return theParticleDefinition;
}

inline const G4ThreeVector& G4DynamicParticle::GetPolarization() const
{
  return thePolarization;
}

inline G4double G4DynamicParticle::GetProperTime() const
{
  return theProperTime;
}

inline G4double G4DynamicParticle::GetTotalEnergy() const
{
  return (theKineticEnergy + theDynamicalMass);
}

inline G4double G4DynamicParticle::GetKineticEnergy() const
{
  return theKineticEnergy;
}

inline G4double G4DynamicParticle::GetLogKineticEnergy() const
{
  if (theLogKineticEnergy == std::numeric_limits<double>::max()) {
    theLogKineticEnergy = (theKineticEnergy > 0.) ? G4Log(theKineticEnergy) : -30;
  }
  return theLogKineticEnergy;
}

inline void G4DynamicParticle::SetMomentumDirection(const G4ThreeVector& aDirection)
{
  theMomentumDirection = aDirection;
}

inline void G4DynamicParticle::SetMomentumDirection(G4double px, G4double py, G4double pz)
{
  theMomentumDirection.setX(px);
  theMomentumDirection.setY(py);
  theMomentumDirection.setZ(pz);
}

inline void G4DynamicParticle::SetPolarization(const G4ThreeVector& vp)
{
  thePolarization = vp;
}

inline void G4DynamicParticle::SetPolarization(G4double polX, G4double polY, G4double polZ)
{
  thePolarization.setX(polX);
  thePolarization.setY(polY);
  thePolarization.setZ(polZ);
}

inline void G4DynamicParticle::SetKineticEnergy(G4double aEnergy)
{
  if (aEnergy != theKineticEnergy) {
    theLogKineticEnergy = std::numeric_limits<double>::max();
    theKineticEnergy = aEnergy;
    theBeta = -1.0;
  }
}

inline void G4DynamicParticle::SetProperTime(G4double atime)
{
  theProperTime = atime;
}

inline const G4DecayProducts* G4DynamicParticle::GetPreAssignedDecayProducts() const
{
  return thePreAssignedDecayProducts;
}

inline void G4DynamicParticle::SetPreAssignedDecayProducts(G4DecayProducts* aDecayProducts)
{
  thePreAssignedDecayProducts = aDecayProducts;
}

inline G4double G4DynamicParticle::GetPreAssignedDecayProperTime() const
{
  return thePreAssignedDecayTime;
}

inline void G4DynamicParticle::SetPreAssignedDecayProperTime(G4double aTime)
{
  thePreAssignedDecayTime = aTime;
}

inline void G4DynamicParticle::SetVerboseLevel(G4int value)
{
  verboseLevel = value;
}

inline G4int G4DynamicParticle::GetVerboseLevel() const
{
  return verboseLevel;
}

inline void G4DynamicParticle::SetPrimaryParticle(G4PrimaryParticle* p)
{
  primaryParticle = p;
}

inline G4PrimaryParticle* G4DynamicParticle::GetPrimaryParticle() const
{
  return primaryParticle;
}

inline G4int G4DynamicParticle::GetPDGcode() const
{
  G4int code = theParticleDefinition->GetPDGEncoding();
  return (code == 0) ? thePDGcode : code;
}

inline void G4DynamicParticle::SetPDGcode(G4int c)
{
  thePDGcode = c;
}

inline void G4DynamicParticle::ComputeBeta() const
{

  theBeta = 1.0;


  if (theDynamicalMass > 0.0 && theKineticEnergy < 1000 * theDynamicalMass) {
    const G4double T = theKineticEnergy / theDynamicalMass;
    theBeta = std::sqrt(T * (T + 2.)) / (T + 1.0);
  }
}

inline G4double G4DynamicParticle::GetBeta() const
{
  if (theBeta < 0.0) {
    ComputeBeta();
  }
  return theBeta;
}
# 274 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4DynamicParticle.hh" 2 3
# 54 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TrackStatus.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4TrackStatus.hh" 3
enum G4TrackStatus
{
  fAlive,

  fStopButAlive,

  fStopAndKill,

  fKillTrackAndSecondaries,

  fSuspend,

  fSuspendAndWait,



  fPostponeToNextEvent

};
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 2 3


# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsModelCatalog.hh" 1 3
# 45 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsModelCatalog.hh" 3
class G4PhysicsModelCatalog {
  public:
    static void Initialize();
    ~G4PhysicsModelCatalog() = default;
    G4PhysicsModelCatalog( const G4PhysicsModelCatalog& ) = delete;
    G4PhysicsModelCatalog& operator=( const G4PhysicsModelCatalog& ) = delete;

    static const G4String GetModelNameFromID( const G4int modelID );
    static const G4String GetModelNameFromIndex( const G4int modelIndex );
    static G4int GetModelID( const G4int modelIndex );
    static G4int GetModelID( const G4String& modelName );
    static G4int GetModelIndex( const G4int modelID );
    static G4int GetModelIndex( const G4String& modelName );
# 75 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4PhysicsModelCatalog.hh" 3
    static G4int Entries();


    static void PrintAllInformation();



    static G4int GetMinAllowedModelIDValue();
    static G4int GetMaxAllowedModelIDValue();


  private:
    G4PhysicsModelCatalog() = default;

    static void SanityCheck();




    inline static void InsertModel( G4int modelID, G4String modelName );

    static G4bool isInitialized;
    static const G4int theMinAllowedModelIDValue = 10000;
    static const G4int theMaxAllowedModelIDValue = 39999;

    static std::vector< G4int >* theVectorOfModelIDs;
    static std::vector< G4String >* theVectorOfModelNames;
};


inline G4int G4PhysicsModelCatalog::GetMinAllowedModelIDValue() {
  return theMinAllowedModelIDValue;
}

inline G4int G4PhysicsModelCatalog::GetMaxAllowedModelIDValue() {
  return theMaxAllowedModelIDValue;
}

inline void G4PhysicsModelCatalog::InsertModel( G4int modelID, G4String modelName ) {
  theVectorOfModelIDs->push_back( modelID );
  theVectorOfModelNames->push_back( modelName );
}
# 58 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 2 3



class G4Step;
class G4MaterialCutsCouple;
class G4VAuxiliaryTrackInformation;
class G4VProcess;

class G4Track
{
  public:

  using ProfilerConfig = G4ProfilerConfig<G4ProfileType::Track>;

    G4Track();

    G4Track(G4DynamicParticle* apValueDynamicParticle,
            G4double aValueTime,
            const G4ThreeVector& aValuePosition);


    G4Track(const G4Track&);


    ~G4Track();


    inline void* operator new(std::size_t);

    inline void operator delete(void* aTrack);


    G4Track& operator=(const G4Track&);


    inline G4bool operator==(const G4Track&);
    inline G4bool operator!=(const G4Track&);


    void CopyTrackInfo(const G4Track&);


    G4int GetTrackID() const;
    void SetTrackID(const G4int aValue);


    G4int GetParentID() const;
    void SetParentID(const G4int aValue);

    const G4DynamicParticle* GetDynamicParticle() const;


    const G4ParticleDefinition* GetParticleDefinition() const;

    G4ParticleDefinition* GetDefinition() const;


    const G4ThreeVector& GetPosition() const;
    void SetPosition(const G4ThreeVector& aValue);


    G4double GetGlobalTime() const;
    void SetGlobalTime(const G4double aValue);


    G4double GetLocalTime() const;
    void SetLocalTime(const G4double aValue);


    G4double GetProperTime() const;
    void SetProperTime(const G4double aValue);


    G4VPhysicalVolume* GetVolume() const;
    G4VPhysicalVolume* GetNextVolume() const;


    G4Material* GetMaterial() const;
    G4Material* GetNextMaterial() const;

    const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
    const G4MaterialCutsCouple* GetNextMaterialCutsCouple() const;

    const G4VTouchable* GetTouchable() const;
    const G4TouchableHandle& GetTouchableHandle() const;
    void SetTouchableHandle(const G4TouchableHandle& apValue);

    const G4VTouchable* GetNextTouchable() const;
    const G4TouchableHandle& GetNextTouchableHandle() const;
    void SetNextTouchableHandle(const G4TouchableHandle& apValue);

    const G4VTouchable* GetOriginTouchable() const;
    const G4TouchableHandle& GetOriginTouchableHandle() const;
    void SetOriginTouchableHandle(const G4TouchableHandle& apValue);

    G4double GetKineticEnergy() const;
    void SetKineticEnergy(const G4double aValue);


    G4double GetTotalEnergy() const;

    const G4ThreeVector& GetMomentumDirection() const;
    void SetMomentumDirection(const G4ThreeVector& aValue);


    G4ThreeVector GetMomentum() const;

    G4double GetVelocity() const;
    void SetVelocity(G4double val);


    G4double CalculateVelocity() const;
    G4double CalculateVelocityForOpticalPhoton() const;

    G4bool UseGivenVelocity() const;
    void UseGivenVelocity(G4bool val);

    const G4ThreeVector& GetPolarization() const;
    void SetPolarization(const G4ThreeVector& aValue);


    G4TrackStatus GetTrackStatus() const;
    void SetTrackStatus(const G4TrackStatus aTrackStatus);


    G4bool IsBelowThreshold() const;
    void SetBelowThresholdFlag(G4bool value = true);




    G4bool IsGoodForTracking() const;
    void SetGoodForTrackingFlag(G4bool value = true);




    G4double GetTrackLength() const;
    void AddTrackLength(const G4double aValue);


    const G4Step* GetStep() const;
    void SetStep(const G4Step* aValue);


    G4int GetCurrentStepNumber() const;
    void IncrementCurrentStepNumber();

    G4double GetStepLength() const;
    void SetStepLength(G4double value);





    const G4ThreeVector& GetVertexPosition() const;
    void SetVertexPosition(const G4ThreeVector& aValue);


    const G4ThreeVector& GetVertexMomentumDirection() const;
    void SetVertexMomentumDirection(const G4ThreeVector& aValue);

    G4double GetVertexKineticEnergy() const;
    void SetVertexKineticEnergy(const G4double aValue);

    const G4LogicalVolume* GetLogicalVolumeAtVertex() const;
    void SetLogicalVolumeAtVertex(const G4LogicalVolume*);

    const G4VProcess* GetCreatorProcess() const;
    void SetCreatorProcess(const G4VProcess* aValue);

    inline void SetCreatorModelID(const G4int id);
    inline G4int GetCreatorModelID() const;
    inline G4int GetCreatorModelIndex() const;
    inline const G4String GetCreatorModelName() const;





    inline const G4ParticleDefinition* GetParentResonanceDef() const;
    inline void SetParentResonanceDef(const G4ParticleDefinition* parent);
    inline G4int GetParentResonanceID() const;
    inline void SetParentResonanceID(const G4int parentID );
    inline G4bool HasParentResonance() const;
    inline G4int GetParentResonancePDGEncoding() const;
    inline G4String GetParentResonanceName() const;
    inline G4double GetParentResonanceMass() const;
# 261 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 3
    G4double GetWeight() const;
    void SetWeight(G4double aValue);


    G4VUserTrackInformation* GetUserInformation() const;
    void SetUserInformation(G4VUserTrackInformation* aValue) const;


    void SetAuxiliaryTrackInformation(G4int id,
                                      G4VAuxiliaryTrackInformation* info) const;
    G4VAuxiliaryTrackInformation* GetAuxiliaryTrackInformation(G4int id) const;
    inline std::map<G4int, G4VAuxiliaryTrackInformation*>*
           GetAuxiliaryTrackInformationMap() const;

    void RemoveAuxiliaryTrackInformation(G4int id);
    void RemoveAuxiliaryTrackInformation(G4String& name);


  private:

    void ClearAuxiliaryTrackInformation();



    G4ThreeVector fPosition;

    G4double fGlobalTime = 0.0;

    G4double fLocalTime = 0.0;

    G4double fTrackLength = 0.0;


    G4double fVelocity = 0.0;

    G4TouchableHandle fpTouchable;
    G4TouchableHandle fpNextTouchable;
    G4TouchableHandle fpOriginTouchable;


    G4DynamicParticle* fpDynamicParticle = nullptr;
    mutable G4TrackStatus fTrackStatus = fAlive;

    G4double fStepLength = 0.0;





    G4double fWeight = 1.0;


    const G4Step* fpStep = nullptr;

    G4ThreeVector fVtxPosition;

    G4ThreeVector fVtxMomentumDirection;

    G4double fVtxKineticEnergy = 0.0;

    const G4LogicalVolume* fpLVAtVertex = nullptr;

    const G4VProcess* fpCreatorProcess = nullptr;


    mutable G4VUserTrackInformation* fpUserInformation = nullptr;

    mutable G4Material* prev_mat = nullptr;
    mutable G4MaterialPropertyVector* groupvel = nullptr;
    mutable G4double prev_velocity = 0.0;
    mutable G4double prev_momentum = 0.0;


    mutable std::map<G4int, G4VAuxiliaryTrackInformation*>*
            fpAuxiliaryTrackInformationMap = nullptr;

    G4int fCurrentStepNumber = 0;


    G4int fCreatorModelID = -1;


    const G4ParticleDefinition* fParentResonanceDef = nullptr;



    G4int fParentResonanceID = 0;



    G4int fParentID = 0;
    G4int fTrackID = 0;

    G4bool fBelowThreshold = false;


    G4bool fGoodForTracking = false;



    G4bool is_OpticalPhoton = false;

    G4bool useGivenVelocity = false;


};

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.icc" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.icc" 3
extern G4Allocator<G4Track>*& aTrackAllocator();






# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 1 3
# 40 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.icc" 2 3

inline void* G4Track::operator new(std::size_t)
{
  if(aTrackAllocator() == nullptr)
  {
    aTrackAllocator() = new G4Allocator<G4Track>;
  }
  return (void*) aTrackAllocator()->MallocSingle();
}

inline void G4Track::operator delete(void* aTrack)
{
  aTrackAllocator()->FreeSingle((G4Track*) aTrack);
}

inline G4bool G4Track::operator==(const G4Track& trk)
{
  return (this == &trk);
}

inline G4bool G4Track::operator!=(const G4Track& trk)
{
  return (this != &trk);
}


inline const G4DynamicParticle* G4Track::GetDynamicParticle() const
{
  return fpDynamicParticle;
}


inline G4ParticleDefinition* G4Track::GetDefinition() const
{
  return fpDynamicParticle->GetDefinition();
}


inline const G4ParticleDefinition* G4Track::GetParticleDefinition() const
{
  return fpDynamicParticle->GetParticleDefinition();
}


inline G4int G4Track::GetParentID() const
{
  return fParentID;
}

inline void G4Track::SetParentID(const G4int aValue)
{
  fParentID = aValue;
}


inline G4int G4Track::GetTrackID() const
{
  return fTrackID;
}

inline void G4Track::SetTrackID(const G4int aValue)
{
  fTrackID = aValue;
}


inline const G4ThreeVector& G4Track::GetPosition() const
{
  return fPosition;
}

inline void G4Track::SetPosition(const G4ThreeVector& aValue)
{
  fPosition = aValue;
}


inline G4double G4Track::GetGlobalTime() const
{
  return fGlobalTime;
}

inline void G4Track::SetGlobalTime(const G4double aValue)
{
  fGlobalTime = aValue;
}


inline G4double G4Track::GetLocalTime() const
{
  return fLocalTime;
}

inline void G4Track::SetLocalTime(const G4double aValue)
{
  fLocalTime = aValue;
}


inline G4double G4Track::GetProperTime() const
{
  return fpDynamicParticle->GetProperTime();
}

inline void G4Track::SetProperTime(const G4double aValue)
{
  fpDynamicParticle->SetProperTime(aValue);
}


inline G4double G4Track::GetVelocity() const
{
  return (useGivenVelocity) ? fVelocity
                            : ((!is_OpticalPhoton)
                                 ? CLHEP::c_light * fpDynamicParticle->GetBeta()
                                 : CalculateVelocityForOpticalPhoton());
}

inline G4double G4Track::CalculateVelocity() const
{
  return GetVelocity();
}

inline void G4Track::SetVelocity(G4double val)
{
  fVelocity = val;
}

inline G4bool G4Track::UseGivenVelocity() const
{
  return useGivenVelocity;
}

inline void G4Track::UseGivenVelocity(G4bool val)
{
  useGivenVelocity = val;
}


inline G4VPhysicalVolume* G4Track::GetVolume() const
{
  return (fpTouchable) ? fpTouchable->GetVolume() : nullptr;
}

inline G4VPhysicalVolume* G4Track::GetNextVolume() const
{
  return (fpNextTouchable) ? fpNextTouchable->GetVolume() : nullptr;
}


inline const G4MaterialCutsCouple* G4Track::GetMaterialCutsCouple() const
{
  return fpStep->GetPreStepPoint()->GetMaterialCutsCouple();
}

inline const G4MaterialCutsCouple* G4Track::GetNextMaterialCutsCouple() const
{
  return fpStep->GetPostStepPoint()->GetMaterialCutsCouple();
}

inline G4Material* G4Track::GetMaterial() const
{
  return fpStep->GetPreStepPoint()->GetMaterial();
}

inline G4Material* G4Track::GetNextMaterial() const
{
  return fpStep->GetPostStepPoint()->GetMaterial();
}


inline const G4VTouchable* G4Track::GetTouchable() const
{
  return fpTouchable();
}

inline const G4TouchableHandle& G4Track::GetTouchableHandle() const
{
  return fpTouchable;
}

inline void G4Track::SetTouchableHandle(const G4TouchableHandle& apValue)
{
  fpTouchable = apValue;
}

inline const G4VTouchable* G4Track::GetNextTouchable() const
{
  return fpNextTouchable();
}

inline const G4TouchableHandle& G4Track::GetNextTouchableHandle() const
{
  return fpNextTouchable;
}

inline void G4Track::SetNextTouchableHandle(const G4TouchableHandle& apValue)
{
  fpNextTouchable = apValue;
}

inline const G4VTouchable* G4Track::GetOriginTouchable() const
{
  return fpOriginTouchable();
}

inline const G4TouchableHandle& G4Track::GetOriginTouchableHandle() const
{
  return fpOriginTouchable;
}

inline void G4Track::SetOriginTouchableHandle(const G4TouchableHandle& apValue)
{
  fpOriginTouchable = apValue;
}


inline G4double G4Track::GetKineticEnergy() const
{
  return fpDynamicParticle->GetKineticEnergy();
}

inline void G4Track::SetKineticEnergy(const G4double aValue)
{
  fpDynamicParticle->SetKineticEnergy(aValue);
}


inline G4double G4Track::GetTotalEnergy() const
{
  return fpDynamicParticle->GetTotalEnergy();
}


inline G4ThreeVector G4Track::GetMomentum() const
{
  return fpDynamicParticle->GetMomentum();
}


inline const G4ThreeVector& G4Track::GetMomentumDirection() const
{
  return fpDynamicParticle->GetMomentumDirection();
}

inline void G4Track::SetMomentumDirection(const G4ThreeVector& aValue)
{
  fpDynamicParticle->SetMomentumDirection(aValue);
}


inline const G4ThreeVector& G4Track::GetPolarization() const
{
  return fpDynamicParticle->GetPolarization();
}

inline void G4Track::SetPolarization(const G4ThreeVector& aValue)
{
  fpDynamicParticle->SetPolarization(aValue);
}


inline G4TrackStatus G4Track::GetTrackStatus() const
{
  return fTrackStatus;
}

inline void G4Track::SetTrackStatus(const G4TrackStatus aTrackStatus)
{
  fTrackStatus = aTrackStatus;
}


inline G4double G4Track::GetTrackLength() const
{
  return fTrackLength;
}

inline void G4Track::AddTrackLength(const G4double aValue)
{
  fTrackLength += aValue;
}



inline G4int G4Track::GetCurrentStepNumber() const
{
  return fCurrentStepNumber;
}

inline void G4Track::IncrementCurrentStepNumber()
{
  ++fCurrentStepNumber;
}


inline G4double G4Track::GetStepLength() const
{
  return fStepLength;
}

inline void G4Track::SetStepLength(G4double value)
{
  fStepLength = value;
}


inline const G4ThreeVector& G4Track::GetVertexPosition() const
{
  return fVtxPosition;
}

inline void G4Track::SetVertexPosition(const G4ThreeVector& aValue)
{
  fVtxPosition = aValue;
}

inline const G4ThreeVector& G4Track::GetVertexMomentumDirection() const
{
  return fVtxMomentumDirection;
}

inline void G4Track::SetVertexMomentumDirection(const G4ThreeVector& aValue)
{
  fVtxMomentumDirection = aValue;
}

inline G4double G4Track::GetVertexKineticEnergy() const
{
  return fVtxKineticEnergy;
}

inline void G4Track::SetVertexKineticEnergy(const G4double aValue)
{
  fVtxKineticEnergy = aValue;
}

inline const G4LogicalVolume* G4Track::GetLogicalVolumeAtVertex() const
{
  return fpLVAtVertex;
}

inline void G4Track::SetLogicalVolumeAtVertex(const G4LogicalVolume* aValue)
{
  fpLVAtVertex = aValue;
}

inline const G4VProcess* G4Track::GetCreatorProcess() const
{




  return fpCreatorProcess;
}

inline void G4Track::SetCreatorProcess(const G4VProcess* aValue)
{
  fpCreatorProcess = aValue;
}

inline void G4Track::SetCreatorModelID(const G4int id)
{
  fCreatorModelID = id;
}

inline G4int G4Track::GetCreatorModelID() const
{
  return fCreatorModelID;
}

inline G4int G4Track::GetCreatorModelIndex() const
{
  return G4PhysicsModelCatalog::GetModelIndex(fCreatorModelID);
}

inline const G4String G4Track::GetCreatorModelName() const
{
  return G4PhysicsModelCatalog::GetModelNameFromID(fCreatorModelID);
}

inline const G4ParticleDefinition* G4Track::GetParentResonanceDef() const
{
  return fParentResonanceDef;
}

inline void G4Track::SetParentResonanceDef(const G4ParticleDefinition* parentDef)
{
  fParentResonanceDef = parentDef;
}

inline G4int G4Track::GetParentResonanceID() const
{
  return fParentResonanceID;
}

inline void G4Track::SetParentResonanceID(const G4int parentID)
{
  fParentResonanceID = parentID;
}

inline G4bool G4Track::HasParentResonance() const {
  return ( fParentResonanceDef != nullptr );
}

inline G4int G4Track::GetParentResonancePDGEncoding() const {
  return ( fParentResonanceDef == nullptr ? 0 : fParentResonanceDef->GetPDGEncoding() );
}

inline G4String G4Track::GetParentResonanceName() const {
  return ( fParentResonanceDef == nullptr ? G4String() : fParentResonanceDef->GetParticleName() );
}

inline G4double G4Track::GetParentResonanceMass() const {
  return fParentResonanceID * CLHEP::keV;
}


inline G4bool G4Track::IsBelowThreshold() const
{
  return fBelowThreshold;
}

inline void G4Track::SetBelowThresholdFlag(G4bool value)
{
  fBelowThreshold = value;
}


inline G4bool G4Track::IsGoodForTracking() const
{
  return fGoodForTracking;
}

inline void G4Track::SetGoodForTrackingFlag(G4bool value)
{
  fGoodForTracking = value;
}


inline void G4Track::SetWeight(G4double aValue)
{
  fWeight = aValue;
}

inline G4double G4Track::GetWeight() const
{
  return fWeight;
}


inline G4VUserTrackInformation* G4Track::GetUserInformation() const
{
  return fpUserInformation;
}

inline void G4Track::SetUserInformation(G4VUserTrackInformation* aValue) const
{
  fpUserInformation = aValue;
}

inline const G4Step* G4Track::GetStep() const
{
  return fpStep;
}

inline void G4Track::SetStep(const G4Step* aValue)
{
  fpStep = aValue;
}

inline std::map<G4int, G4VAuxiliaryTrackInformation*>*
           G4Track::GetAuxiliaryTrackInformationMap() const
{
  return fpAuxiliaryTrackInformationMap;
}
# 369 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Track.hh" 2 3
# 158 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.icc" 2 3

inline G4Track* G4Step::GetTrack() const
{
  return fpTrack;
}

inline void G4Step::SetTrack(G4Track* value)
{
  fpTrack = value;
}

inline void G4Step::InitializeStep(G4Track* aValue)
{
  fpTrack = aValue;
  fpTrack->SetStepLength(0.);


  fStepLength = 0.;
  fTotalEnergyDeposit = 0.;
  fNonIonizingEnergyDeposit = 0.;

  nSecondaryByLastStep = 0;





  fpPreStepPoint->SetSafety(0.0);
  fpPreStepPoint->SetProcessDefinedStep(nullptr);
  fpPreStepPoint->SetStepStatus(fUndefined);



  fpPreStepPoint->SetWeight(fpTrack->GetWeight());
  fpPreStepPoint->SetPosition(fpTrack->GetPosition());
  fpPreStepPoint->SetLocalTime(fpTrack->GetLocalTime());
  fpPreStepPoint->SetGlobalTime(fpTrack->GetGlobalTime());



  auto pParticle = fpTrack->GetDynamicParticle();

  fpPreStepPoint->SetMass(pParticle->GetMass());
  fpPreStepPoint->SetCharge(pParticle->GetCharge());
  fpPreStepPoint->SetProperTime(pParticle->GetProperTime());
  fpPreStepPoint->SetKineticEnergy(pParticle->GetKineticEnergy());
  fpPreStepPoint->SetMomentumDirection(pParticle->GetMomentumDirection());
  fpPreStepPoint->SetPolarization(pParticle->GetPolarization());



  auto lvol = fpTrack->GetTouchable()->GetVolume()->GetLogicalVolume();

  fpPreStepPoint->SetTouchableHandle(fpTrack->GetTouchableHandle());

  fpPreStepPoint->SetMaterial(lvol->GetMaterial());
  fpPreStepPoint->SetMaterialCutsCouple(lvol->GetMaterialCutsCouple());
  fpPreStepPoint->SetSensitiveDetector(lvol->GetSensitiveDetector());


  fpPreStepPoint->SetVelocity(fpTrack->CalculateVelocity());

  (*fpPostStepPoint) = (*fpPreStepPoint);
}

inline void G4Step::UpdateTrack()
{



  fpTrack->SetPosition(fpPostStepPoint->GetPosition());
  fpTrack->SetGlobalTime(fpPostStepPoint->GetGlobalTime());
  fpTrack->SetLocalTime(fpPostStepPoint->GetLocalTime());

  auto* pParticle =
    (G4DynamicParticle*) (fpTrack->GetDynamicParticle());
  pParticle->SetMass(fpPostStepPoint->GetMass());
  pParticle->SetCharge(fpPostStepPoint->GetCharge());
  pParticle->SetProperTime(fpPostStepPoint->GetProperTime());

  pParticle->SetMomentumDirection(fpPostStepPoint->GetMomentumDirection());
  pParticle->SetKineticEnergy(fpPostStepPoint->GetKineticEnergy());
  pParticle->SetPolarization(fpPostStepPoint->GetPolarization());

  fpTrack->SetStepLength(fStepLength);


  fpTrack->SetNextTouchableHandle(fpPostStepPoint->GetTouchableHandle());
  fpTrack->SetWeight(fpPostStepPoint->GetWeight());


  fpTrack->SetVelocity(fpPostStepPoint->GetVelocity());
}

inline std::size_t G4Step::GetNumberOfSecondariesInCurrentStep() const
{
  return fSecondary->size() - nSecondaryByLastStep;
}

inline const G4TrackVector* G4Step::GetSecondary() const
{
  return fSecondary;
}

inline G4TrackVector* G4Step::GetfSecondary()
{
  return fSecondary;
}

inline void G4Step::SetSecondary(G4TrackVector* value)
{
  fSecondary = value;
}

inline G4TrackVector* G4Step::NewSecondaryVector()
{
  fSecondary = new G4TrackVector();
  return fSecondary;
}

inline void G4Step::DeleteSecondaryVector()
{
  if(fSecondary != nullptr)
  {
    fSecondary->clear();
    delete fSecondary;
    fSecondary = nullptr;
  }
}

inline G4bool G4Step::IsFirstStepInVolume() const
{
  return fFirstStepInVolume;
}

inline G4bool G4Step::IsLastStepInVolume() const
{
  return fLastStepInVolume;
}

inline void G4Step::SetFirstStepFlag()
{
  fFirstStepInVolume = true;
}

inline void G4Step::ClearFirstStepFlag()
{
  fFirstStepInVolume = false;
}

inline void G4Step::SetLastStepFlag()
{
  fLastStepInVolume = true;
}

inline void G4Step::ClearLastStepFlag()
{
  fLastStepInVolume = false;
}

inline void
G4Step::SetPointerToVectorOfAuxiliaryPoints(std::vector<G4ThreeVector>* vec)
{
  fpVectorOfAuxiliaryPointsPointer = vec;
}

inline std::vector<G4ThreeVector>*
G4Step::GetPointerToVectorOfAuxiliaryPoints() const
{
  return fpVectorOfAuxiliaryPointsPointer;
}
# 219 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4Step.hh" 2 3
# 35 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3

# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHit.hh" 1 3
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHit.hh" 3
class G4AttDef;
class G4AttValue;
# 48 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VHit.hh" 3
class G4VHit
{
 public:
  G4VHit() = default;
  virtual ~G4VHit() = default;

  G4bool operator==(const G4VHit&) const { return false; }

  virtual void Draw(){};
  virtual void Print(){};




  virtual const std::map<G4String, G4AttDef>* GetAttDefs() const { return nullptr; }






  virtual std::vector<G4AttValue>* CreateAttValues() const { return nullptr; }
};
# 37 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VReadOutGeometry.hh" 1 3
# 33 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VReadOutGeometry.hh" 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SensitiveVolumeList.hh" 1 3
# 55 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4SensitiveVolumeList.hh" 3
class G4SensitiveVolumeList
{
 public:

  G4bool operator==(const G4SensitiveVolumeList& right) const;
  G4bool operator!=(const G4SensitiveVolumeList& right) const;


  G4bool CheckPV(const G4VPhysicalVolume* pvp) const;


  G4bool CheckLV(const G4LogicalVolume* lvp) const;


  const std::vector<G4VPhysicalVolume*>& GetThePhysicalVolumeList() const;
  void SetThePhysicalVolumeList(const std::vector<G4VPhysicalVolume*> value);

  const std::vector<G4LogicalVolume*>& GetTheLogicalVolumeList() const;
  void SetTheLogicalVolumeList(const std::vector<G4LogicalVolume*> value);

 private:


  std::vector<G4VPhysicalVolume*> thePhysicalVolumeList;
  std::vector<G4LogicalVolume*> theLogicalVolumeList;
};
# 34 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VReadOutGeometry.hh" 2 3



class G4Navigator;

class G4VReadOutGeometry
{
 public:
  G4VReadOutGeometry();
  G4VReadOutGeometry(G4String);
  virtual ~G4VReadOutGeometry();

  G4bool operator==(const G4VReadOutGeometry& right) const;
  G4bool operator!=(const G4VReadOutGeometry& right) const;




  void BuildROGeometry();
  virtual G4bool CheckROVolume(G4Step*, G4TouchableHistory*&);

  inline const G4SensitiveVolumeList* GetIncludeList() const { return fincludeList; }
  inline void SetIncludeList(G4SensitiveVolumeList* value) { fincludeList = value; }
  inline const G4SensitiveVolumeList* GetExcludeList() const { return fexcludeList; }
  inline void SetExcludeList(G4SensitiveVolumeList* value) { fexcludeList = value; }
  inline G4String GetName() const { return name; }
  inline void SetName(G4String value) { name = value; }

  inline G4VPhysicalVolume* GetROWorld() const { return ROworld; }

 protected:
  virtual G4VPhysicalVolume* Build() = 0;

  G4VReadOutGeometry(const G4VReadOutGeometry& right);
  G4VReadOutGeometry& operator=(const G4VReadOutGeometry& right);

  virtual G4bool FindROTouchable(G4Step*);

 protected:
  G4VPhysicalVolume* ROworld;
  G4SensitiveVolumeList* fincludeList;
  G4SensitiveVolumeList* fexcludeList;
  G4String name;

  G4Navigator* ROnavigator;
  G4TouchableHistory* touchableHistory;
};
# 38 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3
# 1 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSDFilter.hh" 1 3
# 32 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSDFilter.hh" 3
class G4Step;







class G4VSDFilter
{
 public:
  G4VSDFilter(G4String name);
  virtual ~G4VSDFilter();

  virtual G4bool Accept(const G4Step*) const = 0;

  inline G4String GetName() const { return filterName; }

 protected:
  G4String filterName;
};
# 39 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 2 3
# 49 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 3
class G4VSensitiveDetector
{
 public:



  explicit G4VSensitiveDetector(G4String name);
  G4VSensitiveDetector(const G4VSensitiveDetector& right);
  G4VSensitiveDetector& operator=(const G4VSensitiveDetector& right);
  virtual ~G4VSensitiveDetector() = default;

  G4bool operator==(const G4VSensitiveDetector& right) const;
  G4bool operator!=(const G4VSensitiveDetector& right) const;




  virtual void Initialize(G4HCofThisEvent*) {}
  virtual void EndOfEvent(G4HCofThisEvent*) {}





  virtual void clear() {}

  virtual void DrawAll() {}
  virtual void PrintAll() {}





  inline G4bool Hit(G4Step* aStep)
  {
    G4TouchableHistory* ROhis = nullptr;
    if (! isActive()) return false;
    if (filter != nullptr) {
      if (! (filter->Accept(aStep))) return false;
    }
    if (ROgeometry != nullptr) {
      if (! (ROgeometry->CheckROVolume(aStep, ROhis))) return false;
    }
    return ProcessHits(aStep, ROhis);
  }


  inline void SetROgeometry(G4VReadOutGeometry* value) { ROgeometry = value; }


  inline void SetFilter(G4VSDFilter* value) { filter = value; }

  inline G4int GetNumberOfCollections() const { return G4int(collectionName.size()); }
  inline G4String GetCollectionName(G4int id) const { return collectionName[id]; }
  inline void SetVerboseLevel(G4int vl) { verboseLevel = vl; }
  inline void Activate(G4bool activeFlag) { active = activeFlag; }
  inline G4bool isActive() const { return active; }
  inline G4String GetName() const { return SensitiveDetectorName; }
  inline G4String GetPathName() const { return thePathName; }
  inline G4String GetFullPathName() const { return fullPathName; }
  inline G4VReadOutGeometry* GetROgeometry() const { return ROgeometry; }
  inline G4VSDFilter* GetFilter() const { return filter; }

  virtual G4VSensitiveDetector* Clone() const;

 protected:
# 124 "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4/G4VSensitiveDetector.hh" 3
  virtual G4bool ProcessHits(G4Step* aStep, G4TouchableHistory* ROhist) = 0;




  virtual G4int GetCollectionID(G4int i);

 protected:



  G4CollectionNameVector collectionName;

  G4String SensitiveDetectorName;
  G4String thePathName;
  G4String fullPathName;
  G4int verboseLevel{0};
  G4bool active{true};
  G4VReadOutGeometry* ROgeometry{nullptr};
  G4VSDFilter* filter{nullptr};
};
# 14 "include/simulation/kernel/SensitiveDetectorBase.h" 2
class G4Step;





namespace Belle2 {
  namespace Simulation {


    class SensitiveDetectorBase : public G4VSensitiveDetector {
    public:





      SensitiveDetectorBase(const std::string& name, Const::EDetector subdetector):
        G4VSensitiveDetector(name), m_subdetector(subdetector) {}


      virtual ~SensitiveDetectorBase() {}


      static const std::map<std::string, RelationArray::EConsolidationAction>& getMCParticleRelations() { return s_mcRelations; }







      static void setActive(bool activeStatus) { s_active = activeStatus; }
# 55 "include/simulation/kernel/SensitiveDetectorBase.h"
      static void registerMCParticleRelation(const std::string& name,
                                             RelationArray::EConsolidationAction ignoreAction = RelationArray::c_negativeWeight);





      static void registerMCParticleRelation(const RelationArray& relation,
                                             RelationArray::EConsolidationAction ignoreAction = RelationArray::c_negativeWeight) { registerMCParticleRelation(relation.getName(), ignoreAction); }

    protected:
# 75 "include/simulation/kernel/SensitiveDetectorBase.h"
      virtual bool step(G4Step* step, G4TouchableHistory* ROhist) = 0;
    private:




      virtual bool ProcessHits(G4Step* aStep, G4TouchableHistory* aROhist);

      static std::map<std::string, RelationArray::EConsolidationAction> s_mcRelations;

      static bool s_active;

      Const::EDetector m_subdetector;
    };

    inline bool SensitiveDetectorBase::ProcessHits(G4Step* aStep, G4TouchableHistory* aROhist)
    {
      if (!s_active) return false;
      bool result = step(aStep, aROhist);

      if (result && (m_subdetector != Const::invalidDetector)) TrackInfo::getInfo(*aStep->GetTrack()).addSeenInDetector(m_subdetector);
      return result;
    }

  }
}
# 12 "include/simulation/background/BkgSensitiveDetector.h" 2



namespace Belle2 {





  class BkgSensitiveDetector : public Simulation::SensitiveDetectorBase {

  public:







    explicit BkgSensitiveDetector(const char* subDet, int iden = 0);






    bool step(G4Step* aStep, G4TouchableHistory*) override;


  private:


    int m_subDet;


    int m_identifier;


    int m_trackID;


    ROOT::Math::XYZVector m_startPos;


    ROOT::Math::XYZVector m_startMom;


    double m_startTime;


    double m_startEnergy;


    double m_energyDeposit;


    double m_trackLength;


    int m_eclrepscale;

  };
}
# 22 "klm/bklm/geometry/src/GeometryPar.cc" 2

using namespace Belle2::bklm;

GeometryPar* GeometryPar::m_Instance = nullptr;

GeometryPar* GeometryPar::instance(void)
{
  if (m_Instance)
    return m_Instance;
  do { { LogVariableStream varStream; varStream << "instance() called without initialization"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 31, 0)); }; exit(1); } while(false);
  return nullptr;
}

GeometryPar* GeometryPar::instance(const GearDir& content)
{
  if (!m_Instance)
    m_Instance = new GeometryPar(content);
  return m_Instance;
}

GeometryPar* GeometryPar::instance(const BKLMGeometryPar& element)
{
  if (!m_Instance)
    m_Instance = new GeometryPar(element);
  return m_Instance;
}

GeometryPar::GeometryPar(const GearDir& content) :
  m_DoBeamBackgroundStudy(false),
  m_NSector(BKLMElementNumbers::getMaximalSectorNumber()),
  m_NLayer(BKLMElementNumbers::getMaximalLayerNumber())
{
  clear();
  read(content);
  calculate();
}

GeometryPar::GeometryPar(const BKLMGeometryPar& element) :
  m_DoBeamBackgroundStudy(false),
  m_NSector(BKLMElementNumbers::getMaximalSectorNumber()),
  m_NLayer(BKLMElementNumbers::getMaximalLayerNumber())
{
  clear();
  readFromDB(element);
  calculate();
}

GeometryPar::~GeometryPar()
{
  clear();
}

void GeometryPar::clear()
{
  for (std::map<int, Module*>::iterator m = m_Modules.begin(); m != m_Modules.end(); ++m) { delete m->second; }
  m_Modules.clear();

  m_Alignments.clear();
  m_Displacements.clear();
}


void GeometryPar::read(const GearDir& content)
{

  char name[80] = "";
  m_DoBeamBackgroundStudy = content.getBool("BeamBackgroundStudy");
  m_Rotation = content.getAngle("Rotation");
  m_OffsetZ = content.getLength("OffsetZ");
  m_Phi = content.getLength("Phi");
  m_NSector = content.getNumberNodes("Sectors/Forward/Sector");
  if (m_NSector > BKLMElementNumbers::getMaximalSectorNumber()) {
    do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): sector array size exceeded:" << LogVar("# of sectors", m_NSector) << LogVar("array size", BKLMElementNumbers::getMaximalSectorNumber()); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 96, 0)); }; exit(1); } while(false);


  }
  m_SolenoidOuterRadius = content.getLength("SolenoidOuterRadius");
  m_OuterRadius = content.getLength("OuterRadius");
  m_HalfLength = content.getLength("HalfLength");
  m_NLayer = content.getNumberNodes("Layers/Layer");
  if (m_NLayer > BKLMElementNumbers::getMaximalLayerNumber()) {
    do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): layer array size exceeded:" << LogVar("# of layers", m_NLayer) << LogVar("array size", BKLMElementNumbers::getMaximalLayerNumber()); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 105, 0)); }; exit(1); } while(false);


  }

  m_IronNominalHeight = content.getLength("Layers/IronNominalHeight");
  m_IronActualHeight = content.getLength("Layers/IronActualHeight");
  m_Gap1NominalHeight = content.getLength("Layers/Layer[@layer=\"1\"]/GapNominalHeight");
  m_GapNominalHeight = content.getLength("Layers/GapNominalHeight");
  m_Gap1InnerRadius = content.getLength("Layers/InnerRadius");
  m_Gap1IronWidth = content.getLength("Layers/Layer[@layer=\"1\"]/GapIronWidth");
  m_GapIronWidth = content.getLength("Layers/GapIronWidth");
  m_GapLength = content.getLength("Layers/GapLength");

  m_NZStrips = content.getInt("Layers/NZStrips");
  m_NZStripsChimney = content.getInt("Layers/NZStripsChimney");
  m_NZScints = content.getInt("Layers/NZScintillators");
  m_NZScintsChimney = content.getInt("Layers/NZScintillatorsChimney");
  if (m_NZScints > NZSCINT) {
    do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): z-scint array size exceeded:" << LogVar("# of z scintillators", m_NZScints) << LogVar("array size", NZSCINT); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 124, 0)); }; exit(1); } while(false);


  }
  if (m_NZScintsChimney > NZSCINT) {
    do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): chimney sector z-scint array size exceeded:" << LogVar("# of z scintillators", m_NZScintsChimney) << LogVar("array size", NZSCINT); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 129, 0)); }; exit(1); } while(false);


  }

  m_ModuleLength = content.getLength("Module/Length");
  m_ModuleLengthChimney = content.getLength("Module/LengthChimney");
  m_ModuleCoverHeight = content.getLength("Module/CoverHeight");
  m_ModuleCopperHeight = content.getLength("Module/CopperHeight");
  m_ModuleFoamHeight = content.getLength("Module/FoamHeight");
  m_ModuleMylarHeight = content.getLength("Module/MylarHeight");
  m_ModuleGlassHeight = content.getLength("Module/GlassHeight");
  m_ModuleGasHeight = content.getLength("Module/GasHeight");
  m_ModuleFrameWidth = content.getLength("Module/FrameWidth");
  m_ModuleFrameThickness = content.getLength("Module/FrameThickness");
  m_ModuleGasSpacerWidth = content.getLength("Module/SpacerWidth");
  m_ModulePolystyreneInnerHeight = content.getLength("Module/PolystyreneInnerHeight");
  m_ModulePolystyreneOuterHeight = content.getLength("Module/PolystyreneOuterHeight");
  m_ScintWidth = content.getLength("Module/Scintillator/Width");
  m_ScintHeight = content.getLength("Module/Scintillator/Height");
  m_ScintBoreRadius = content.getLength("Module/Scintillator/BoreRadius");
  m_ScintFiberRadius = content.getLength("Module/Scintillator/FiberRadius");
  m_ScintTiO2ThicknessTop = content.getLength("Module/Scintillator/TiO2ThicknessTop");
  m_ScintTiO2ThicknessSide = content.getLength("Module/Scintillator/TiO2ThicknessSide");

  m_ChimneyLength = content.getLength("Chimney/Length");
  m_ChimneyWidth = content.getLength("Chimney/Width");
  m_ChimneyCoverThickness = content.getLength("Chimney/CoverThickness");
  m_ChimneyHousingInnerRadius = content.getLength("Chimney/HousingInnerRadius");
  m_ChimneyHousingOuterRadius = content.getLength("Chimney/HousingOuterRadius");
  m_ChimneyShieldInnerRadius = content.getLength("Chimney/ShieldInnerRadius");
  m_ChimneyShieldOuterRadius = content.getLength("Chimney/ShieldOuterRadius");
  m_ChimneyPipeInnerRadius = content.getLength("Chimney/PipeInnerRadius");
  m_ChimneyPipeOuterRadius = content.getLength("Chimney/PipeOuterRadius");

  m_RibThickness = content.getLength("RibThickness");
  m_CablesWidth = content.getLength("CablesWidth");
  m_BraceWidth = content.getLength("BraceWidth");
  m_BraceWidthChimney = content.getLength("BraceWidthChimney");

  m_SupportPlateWidth = content.getLength("SupportPlateWidth");
  m_SupportPlateHeight = content.getLength("SupportPlateHeight");
  m_SupportPlateLength = content.getLength("SupportPlateLength");
  m_SupportPlateLengthChimney = content.getLength("SupportPlateLengthChimney");

  m_BracketWidth = content.getLength("BracketWidth");
  m_BracketThickness = content.getLength("BracketThickness");
  m_BracketLength = content.getLength("BracketLength");
  m_BracketRibWidth = content.getLength("BracketRibWidth");
  m_BracketRibThickness = content.getLength("BracketRibThickness");
  m_BracketInnerRadius = content.getLength("BracketInnerRadius");
  m_BracketInset = content.getLength("BracketInset");
  m_BracketCutoutDphi = content.getAngle("BracketCutoutDphi");

  m_NReadoutStation = content.getNumberNodes("Readout/Stations/Station");
  if (m_NReadoutStation > NSTATION) {
    do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): readout stations array size exceeded:" << LogVar("# of readout stations", m_NReadoutStation) << LogVar("array size", NSTATION); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 185, 0)); }; exit(1); } while(false);


  }
  for (int station = 1; station <= m_NReadoutStation; ++station) {
    sprintf(name, "/Readout/Stations/Station[@station=\"%d\"]", station);
    GearDir stationContent = content;
    stationContent.append(name);
    m_ReadoutStationIsPhi[station - 1] = stationContent.getBool("IsPhi");
    m_ReadoutStationPosition[station - 1] = stationContent.getLength("Position");
  }
  m_ReadoutContainerLength = content.getLength("Readout/Container/Length");
  m_ReadoutContainerWidth = content.getLength("Readout/Container/Width");
  m_ReadoutContainerHeight = content.getLength("Readout/Container/Height");
  m_ReadoutCarrierLength = content.getLength("Readout/Carrier/Length");
  m_ReadoutCarrierWidth = content.getLength("Readout/Carrier/Width");
  m_ReadoutCarrierHeight = content.getLength("Readout/Carrier/Height");
  m_ReadoutPreamplifierLength = content.getLength("Readout/Preamplifier/Length");
  m_ReadoutPreamplifierWidth = content.getLength("Readout/Preamplifier/Width");
  m_ReadoutPreamplifierHeight = content.getLength("Readout/Preamplifier/Height");
  m_ReadoutPreamplifierPosition = content.getArray("Readout/Preamplifier/Position");
  m_ReadoutConnectorsLength = content.getLength("Readout/Connectors/Length");
  m_ReadoutConnectorsWidth = content.getLength("Readout/Connectors/Width");
  m_ReadoutConnectorsHeight = content.getLength("Readout/Connectors/Height");
  m_ReadoutConnectorsPosition = content.getLength("Readout/Connectors/Position");
  m_MPPCHousingRadius = content.getLength("Readout/MPPC/Housing/Radius");
  m_MPPCHousingLength = content.getLength("Readout/MPPC/Housing/Length");
  m_MPPCLength = content.getLength("Readout/MPPC/Sensor/Length");
  m_MPPCWidth = content.getLength("Readout/MPPC/Sensor/Width");
  m_MPPCHeight = content.getLength("Readout/MPPC/Sensor/Height");

  for (int layer = 1; layer <= m_NLayer; ++layer) {
    sprintf(name, "/Layers/Layer[@layer=\"%d\"]", layer);
    GearDir layerContent = content;
    layerContent.append(name);
    m_HasRPCs[layer - 1] = layerContent.getBool("HasRPCs");
    m_NPhiStrips[layer - 1] = layerContent.getInt("PhiStrips/NStrips");
    m_PhiStripWidth[layer - 1] = layerContent.getLength("PhiStrips/Width");
    m_ZStripWidth[layer - 1] = layerContent.getLength("ZStrips/Width");
    m_ScintEnvelopeOffsetSign[layer - 1] = layerContent.getInt("ScintEnvelopeOffsetSign");
    m_NPhiScints[layer - 1] = layerContent.getInt("PhiScintillators/NScints", 0);
    if (m_NPhiScints[layer - 1] > NPHISCINT) {
      do { { LogVariableStream varStream; varStream << "BKLM GeometryPar::read(): phi-scint array size exceeded:" << LogVar("in zero-based layer", layer - 1) << LogVar("# phi scintillators", m_NPhiScints[layer - 1]) << LogVar("array size", NPHISCINT); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 228, 0)); }; exit(1); } while(false);



    }
    for (int scint = 1; scint <= m_NZScints; ++scint) {
      sprintf(name, "/ZScintillators/Scint[@scint=\"%d\"]", scint);
      GearDir scintContent(layerContent);
      scintContent.append(name);
      m_ZScintDLength[layer - 1][scint - 1] = scintContent.getLength("DLength", 0.0);
    }
  }

  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
    bool isForward = (section == BKLMElementNumbers::c_ForwardSection);
    for (int sector = 1; sector <= m_NSector; ++sector) {
      sprintf(name, "/Sectors/%s/Sector[@sector=\"%d\"]", (isForward ? "Forward" : "Backward"), sector);
      GearDir sectorContent(content);
      sectorContent.append(name);
      m_SectorRotation[section][sector - 1] = sectorContent.getAngle("Phi");
      for (int layer = 1; layer <= m_NLayer; ++layer) {
        GearDir layerContent(sectorContent);
        sprintf(name, "/Layer[@layer=\"%d\"]", layer);
        layerContent.append(name);
        m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/X");
        m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/Y");
        m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/Z");
        m_IsFlipped[section][sector - 1][layer - 1] = layerContent.getBool("Flip", false);
      }
    }
  }
}


void GeometryPar::readFromDB(const BKLMGeometryPar& element)
{

  m_DoBeamBackgroundStudy = element.doBeamBackgroundStudy();
  m_Rotation = element.getRotation();
  m_OffsetZ = element.getOffsetZ();
  m_Phi = element.getPhi();
  m_NSector = element.getNSector();
  m_SolenoidOuterRadius = element.getSolenoidOuterRadius();
  m_OuterRadius = element.getOuterRadius();
  m_HalfLength = element.getHalfLength();
  m_NLayer = element.getNLayer();

  m_IronNominalHeight = element.getIronNominalHeight();
  m_IronActualHeight = element.getIronActualHeight();
  m_Gap1NominalHeight = element.getGap1NominalHeight();
  m_GapNominalHeight = element.getGapNominalHeight();
  m_Gap1InnerRadius = element.getGap1InnerRadius();
  m_Gap1IronWidth = element.getGap1IronWidth();
  m_GapIronWidth = element.getGapIronWidth();
  m_GapLength = element.getGapLength();

  m_NZStrips = element.getNZStrips();
  m_NZStripsChimney = element.getNZStripsChimney();
  m_NZScints = element.getNZScints();
  m_NZScintsChimney = element.getNZScintsChimney();

  m_ModuleLength = element.getModuleLength();
  m_ModuleLengthChimney = element.getModuleLengthChimney();
  m_ModuleCoverHeight = element.getModuleCoverHeight();
  m_ModuleCopperHeight = element.getModuleCopperHeight();
  m_ModuleFoamHeight = element.getModuleFoamHeight();
  m_ModuleMylarHeight = element.getModuleMylarHeight();
  m_ModuleGlassHeight = element.getModuleGlassHeight();
  m_ModuleGasHeight = element.getModuleGasHeight();
  m_ModuleFrameWidth = element.getModuleFrameWidth();
  m_ModuleFrameThickness = element.getModuleFrameThickness();
  m_ModuleGasSpacerWidth = element.getModuleGasSpacerWidth();
  m_ModulePolystyreneInnerHeight = element.getModulePolystyreneInnerHeight();
  m_ModulePolystyreneOuterHeight = element.getModulePolystyreneOuterHeight();
  m_ScintWidth = element.getScintWidth();
  m_ScintHeight = element.getScintHeight();
  m_ScintBoreRadius = element.getScintBoreRadius();
  m_ScintFiberRadius = element.getScintFiberRadius();
  m_ScintTiO2ThicknessTop = element.getScintTiO2ThicknessTop();
  m_ScintTiO2ThicknessSide = element.getScintTiO2ThicknessSide();

  m_ChimneyLength = element.getChimneyLength();
  m_ChimneyWidth = element.getChimneyWidth();
  m_ChimneyCoverThickness = element.getChimneyCoverThickness();
  m_ChimneyHousingInnerRadius = element.getChimneyHousingInnerRadius();
  m_ChimneyHousingOuterRadius = element.getChimneyHousingOuterRadius();
  m_ChimneyShieldInnerRadius = element.getChimneyShieldInnerRadius();
  m_ChimneyShieldOuterRadius = element.getChimneyShieldOuterRadius();
  m_ChimneyPipeInnerRadius = element.getChimneyPipeInnerRadius();
  m_ChimneyPipeOuterRadius = element.getChimneyPipeOuterRadius();

  m_RibThickness = element.getRibThickness();
  m_CablesWidth = element.getCablesWidth();
  m_BraceWidth = element.getBraceWidth();
  m_BraceWidthChimney = element.getBraceWidthChimney();

  m_SupportPlateWidth = element.getSupportPlateWidth();
  m_SupportPlateHeight = element.getSupportPlateHeight();
  m_SupportPlateLength = element.getSupportPlateLength();
  m_SupportPlateLengthChimney = element.getSupportPlateLengthChimney();

  m_BracketWidth = element.getBracketWidth();
  m_BracketThickness = element.getBracketThickness();
  m_BracketLength = element.getBracketLength();
  m_BracketRibWidth = element.getBracketRibWidth();
  m_BracketRibThickness = element.getBracketRibThickness();
  m_BracketInnerRadius = element.getBracketInnerRadius();
  m_BracketInset = element.getBracketInset();
  m_BracketCutoutDphi = element.getBracketCutoutDphi();

  m_NReadoutStation = element.getNReadoutStation();
  for (int station = 1; station <= m_NReadoutStation; ++station) {
    m_ReadoutStationIsPhi[station - 1] = element.getReadoutStationIsPhi(station);
    m_ReadoutStationPosition[station - 1] = element.getReadoutStationPosition(station);
  }
  m_ReadoutContainerLength = element.getReadoutContainerLength();
  m_ReadoutContainerWidth = element.getReadoutContainerWidth();
  m_ReadoutContainerHeight = element.getReadoutContainerHeight();
  m_ReadoutCarrierLength = element.getReadoutCarrierLength();
  m_ReadoutCarrierWidth = element.getReadoutCarrierWidth();
  m_ReadoutCarrierHeight = element.getReadoutCarrierHeight();
  m_ReadoutPreamplifierLength = element.getReadoutPreamplifierLength();
  m_ReadoutPreamplifierWidth = element.getReadoutPreamplifierWidth();
  m_ReadoutPreamplifierHeight = element.getReadoutPreamplifierHeight();
  for (int preamp = 1; preamp <= element.getNReadoutPreamplifierPosition(); ++preamp) {
    m_ReadoutPreamplifierPosition.push_back(element.getReadoutPreamplifierPosition(preamp));
  }
  m_ReadoutConnectorsLength = element.getReadoutConnectorsLength();
  m_ReadoutConnectorsWidth = element.getReadoutConnectorsWidth();
  m_ReadoutConnectorsHeight = element.getReadoutConnectorsHeight();
  m_ReadoutConnectorsPosition = element.getReadoutConnectorsPosition();
  m_MPPCHousingRadius = element.getMPPCHousingRadius();
  m_MPPCHousingLength = element.getMPPCHousingLength();
  m_MPPCLength = element.getMPPCLength();
  m_MPPCWidth = element.getMPPCWidth();
  m_MPPCHeight = element.getMPPCHeight();


  for (int layer = 1; layer <= m_NLayer; ++layer) {
    m_HasRPCs[layer - 1] = element.hasRPCs(layer);
    m_NPhiStrips[layer - 1] = element.getNPhiStrips(layer);
    m_PhiStripWidth[layer - 1] = element.getPhiStripWidth(layer);
    m_ZStripWidth[layer - 1] = element.getZStripWidth(layer);
    m_NPhiScints[layer - 1] = (m_HasRPCs[layer - 1] ? 0 : element.getNPhiScints(layer));
    m_ScintEnvelopeOffsetSign[layer - 1] = (m_HasRPCs[layer - 1] ? 0 : element.getScintEnvelopeOffsetSign(layer));
    for (int scint = 1; scint <= m_NZScints; ++scint) {
      m_ZScintDLength[layer - 1][scint - 1] = (m_HasRPCs[layer - 1] ? 0.0 : element.getZScintDLength(layer, scint));
    }
  }

  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
    for (int sector = 1; sector <= m_NSector; ++sector) {
      m_SectorRotation[section][sector - 1] = element.getSectorRotation(section, sector);
      for (int layer = 1; layer <= m_NLayer; ++layer) {
        m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftX(section, sector, layer);
        m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftY(section, sector, layer);
        m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftZ(section, sector, layer);
        m_IsFlipped[section][sector - 1][layer - 1] = false;
        if (layer <= NSCINTLAYER) {
          m_IsFlipped[section][sector - 1][layer - 1] = element.isFlipped(section, sector, layer);
        }
      }
    }
  }


}


void GeometryPar::calculate(void)
{
  m_Gap1ActualHeight = m_Gap1NominalHeight + (m_IronNominalHeight - m_IronActualHeight) / 2.0;
  m_GapActualHeight = m_GapNominalHeight + (m_IronNominalHeight - m_IronActualHeight);
  m_Layer1Height = m_IronNominalHeight + m_Gap1NominalHeight;
  m_LayerHeight = m_IronNominalHeight + m_GapNominalHeight;
  m_GapInnerRadius = m_Gap1InnerRadius + m_Layer1Height - m_LayerHeight;
  m_ModuleReadoutHeight = m_ModuleFoamHeight + (m_ModuleCopperHeight + m_ModuleMylarHeight) * 2.0;
  m_ModuleHeight = (m_ModuleCoverHeight + m_ModuleReadoutHeight + m_ModuleGasHeight + m_ModuleGlassHeight * 2.0) * 2.0;


  readDisplacedGeoFromDB();

  readAlignmentFromDB();

  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
    bool isForward = (section == BKLMElementNumbers::c_ForwardSection);
    for (int sector = 1; sector <= m_NSector; ++sector) {
      bool hasChimney = (!isForward) && (sector == BKLMElementNumbers::c_ChimneySector);
      int nZStrips = (hasChimney ? m_NZStripsChimney : m_NZStrips);
      int nZScints = (hasChimney ? m_NZScintsChimney : m_NZScints);
      CLHEP::HepRotation rotation;
      if (!isForward)
        rotation.rotateX(3.14159265358979323846);
      rotation.rotateZ(m_SectorRotation[section][sector - 1]);
      for (int layer = 1; layer <= m_NLayer; ++layer) {
        bool isFlipped = m_IsFlipped[section][sector - 1][layer - 1];
        CLHEP::Hep3Vector localReconstructionShift(m_LocalReconstructionShiftX[section][sector - 1][layer - 1],
                                                   m_LocalReconstructionShiftY[section][sector - 1][layer - 1],
                                                   m_LocalReconstructionShiftZ[section][sector - 1][layer - 1]);
        double dx = getActiveMiddleRadius(section, sector, layer);
        double dz = getModuleHalfSize(layer, hasChimney).z() - getModuleInteriorHalfSize2(layer, hasChimney).z();
        CLHEP::Hep3Vector localOrigin(dx, 0.0, dz);
        int moduleID = BKLMElementNumbers::moduleNumber(
                         section, sector, layer);
        if (m_HasRPCs[layer - 1]) {
          localOrigin.setZ(localOrigin.z() + getModuleInteriorHalfSize1(layer, hasChimney).z() - getGasHalfSize(layer, hasChimney).z());
          Module* pModule = new Module(m_PhiStripWidth[layer - 1],
                                       (layer == 1 ? 2 : 1),
                                       m_NPhiStrips[layer - 1] - (layer == 1 ? 1 : 0),
                                       m_ZStripWidth[layer - 1],
                                       nZStrips,
                                       CLHEP::Hep3Vector(0.0, 0.0, m_OffsetZ) + rotation(localOrigin),
                                       localReconstructionShift,
                                       rotation
                                      );
          pModule->setDisplacedGeo(getModuleDisplacedGeo(section, sector, layer));
          pModule->setAlignment(getModuleAlignment(section, sector, layer));
          m_Modules.insert(std::pair<int, Module*>(moduleID, pModule));
        } else {
          double dy = getScintEnvelopeOffset(layer, hasChimney).y() * getScintEnvelopeOffsetSign(layer) * (isFlipped ? -1.0 : 1.0);
          localOrigin.setY(dy);
          Module* pModule = new Module(m_ScintWidth,
                                       m_NPhiScints[layer - 1],
                                       getScintEnvelopeOffsetSign(layer),
                                       nZScints,
                                       CLHEP::Hep3Vector(0.0, 0.0, m_OffsetZ) + rotation(localOrigin),
                                       localReconstructionShift,
                                       rotation,
                                       isFlipped
                                      );
          pModule->setDisplacedGeo(getModuleDisplacedGeo(section, sector, layer));
          pModule->setAlignment(getModuleAlignment(section, sector, layer));
          m_Modules.insert(std::pair<int, Module*>(moduleID, pModule));
          double base = -0.5 * (m_NPhiScints[layer - 1] + 1) * m_ScintWidth;
          for (int scint = 1; scint <= m_NPhiScints[layer - 1]; ++scint) {
            double length = nZScints * m_ScintWidth;
            if (length > m_MaximalPhiStripLength)
              m_MaximalPhiStripLength = length;
            pModule->addPhiScint(scint,
                                 length,
                                 0.0,
                                 base + scint * m_ScintWidth
                                );
          }
          base = -0.5 * (nZScints + 1) * m_ScintWidth;
          for (int scint = 1; scint <= nZScints; ++scint) {
            int scint0 = m_NZScints - getNZScints(hasChimney);
            double dLength = m_ZScintDLength[layer - 1][scint0 + scint - 1];
            double length = m_NPhiScints[layer - 1] * m_ScintWidth + dLength;
            if (length > m_MaximalZStripLength)
              m_MaximalZStripLength = length;
            pModule->addZScint(scint,
                               length,
                               -0.5 * dLength,
                               base + scint * m_ScintWidth
                              );
          }
        }
      }
    }
  }

}

double GeometryPar::getLayerInnerRadius(int layer) const
{
  if (layer == 1) {
    return m_Gap1InnerRadius;
  }
  if (layer > m_NLayer) {
    return m_OuterRadius;
  }
  return m_GapInnerRadius - (m_IronNominalHeight - m_IronActualHeight) / 2.0 + m_LayerHeight * (layer - 1);
}

double GeometryPar::getLayerOuterRadius(int layer) const
{
  return getLayerInnerRadius(layer + 1);
}

const CLHEP::Hep3Vector GeometryPar::getGapHalfSize(int layer, bool hasChimney) const
{
  double r, ds, dx;
  if (layer == 1) {
    r = m_Gap1InnerRadius + m_Gap1NominalHeight;
    ds = m_Gap1IronWidth;
    dx = 0.5 * m_Gap1ActualHeight;
  } else {
    r = m_GapInnerRadius + m_GapNominalHeight + m_LayerHeight * (layer - 1);
    ds = m_GapIronWidth;
    dx = 0.5 * m_GapActualHeight;
  }
  double dz = 0.5 * (hasChimney ? m_GapLength - m_ChimneyLength : m_GapLength);
  return CLHEP::Hep3Vector(dx, r * tan(3.14159265358979323846 / m_NSector) - ds, dz);

}

const CLHEP::Hep3Vector GeometryPar::getModuleHalfSize(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getGapHalfSize(layer, hasChimney);
  size.setX(0.5 * m_ModuleHeight);
  size.setZ(0.5 * (hasChimney ? m_ModuleLengthChimney : m_ModuleLength));
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getModuleInteriorHalfSize1(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getModuleHalfSize(layer, hasChimney);
  size.setX(size.x() - m_ModuleCoverHeight);
  size.setY(size.y() - m_ModuleFrameWidth);
  size.setZ(size.z() - m_ModuleFrameWidth);
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getModuleInteriorHalfSize2(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getModuleHalfSize(layer, hasChimney);
  size.setX(size.x() - m_ModuleFrameThickness - m_ModuleCoverHeight);
  size.setY(size.y() - m_ModuleFrameThickness);
  size.setZ(size.z() - m_ModuleFrameThickness);
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getElectrodeHalfSize(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getModuleInteriorHalfSize1(layer, hasChimney);
  size.setX(2.0 * m_ModuleGlassHeight + m_ModuleGasHeight);
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getGasHalfSize(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getElectrodeHalfSize(layer, hasChimney);
  size.setX(0.5 * m_ModuleGasHeight);
  size.setY(size.y() - m_ModuleGasSpacerWidth);
  size.setZ(size.z() - m_ModuleGasSpacerWidth);
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getAirHalfSize(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector size = getModuleInteriorHalfSize2(layer, hasChimney);
  size.setX(m_ScintHeight);
  return size;
}

const CLHEP::Hep3Vector GeometryPar::getScintEnvelopeHalfSize(int layer, bool hasChimney) const
{
  return CLHEP::Hep3Vector(0.5 * m_ScintHeight,
                           0.5 * m_ScintWidth * getNPhiScints(layer),
                           0.5 * m_ScintWidth * getNZScints(hasChimney)
                          );
}

int GeometryPar::getNPhiScints(int layer) const
{
  if ((layer <= 0) || (layer > m_NLayer))
    return 0;
  return m_NPhiScints[layer - 1];
}

double GeometryPar::getBKLMLayerArea(int section, int sector, int layer) const
{

  if (section < 0 || section > 1 || sector < 1 || sector > m_NSector || layer <= 0 || layer > m_NLayer) {
    do { { LogVariableStream varStream; varStream << "GeometryPar::getBKLMLayerArea(): invalid section, sector, or layer" << LogVar("section", section) << LogVar("sector", sector) << LogVar("layer", layer); Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Error, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 593, 0)); } } while(false);



    return 0.0;
  }
  double area = 0.0;
  bool hasChimney = (section == 0 && sector == 3);

  if (!hasRPCs(layer)) {

    int nPhiScints = getNPhiScints(layer);
    int nZScints = getNZScints(hasChimney);
    area = nPhiScints * m_ScintWidth * nZScints * m_ScintWidth;
  } else {

    int nPhiStrips = m_NPhiStrips[layer - 1];
    double phiStripWidth = m_PhiStripWidth[layer - 1];
    double zStripWidth = m_ZStripWidth[layer - 1];
    int nZStrips = getNZStrips(hasChimney);
    area = nPhiStrips * phiStripWidth * nZStrips * zStripWidth;
  }
  return area;
}

double GeometryPar::getPolystyreneOffsetX(void) const
{
  return 0.5 * (m_ModulePolystyreneInnerHeight - m_ModulePolystyreneOuterHeight);
}

double GeometryPar::getGapMiddleRadius(int layer) const
{
  if (layer == 1) {
    return m_Gap1InnerRadius + 0.5 * m_Gap1ActualHeight;
  }
  return m_GapInnerRadius + 0.5 * m_GapActualHeight + m_LayerHeight * (layer - 1);
}

double GeometryPar::getModuleMiddleRadius(int layer) const
{
  if (layer == 1) {
    return m_Gap1InnerRadius + 0.5 * m_Gap1NominalHeight;
  }
  return m_GapInnerRadius + 0.5 * m_GapNominalHeight + m_LayerHeight * (layer - 1);
}

double GeometryPar::getActiveMiddleRadius(int section, int sector, int layer) const
{





  double dx = getModuleMiddleRadius(layer) - getGapMiddleRadius(layer);
  int s1 = sector - 1;
  int s2 = m_NSector / 2;
  if (s1 % s2 == 0) {
    dx = 0.0;
  } else if (s1 > s2) {
    dx = -dx;
  }
  double r = getGapMiddleRadius(layer) + dx;
  if (!hasRPCs(layer)) {
    if (m_IsFlipped[section][sector - 1][layer - 1]) {
      r -= getPolystyreneOffsetX();
    } else {
      r += getPolystyreneOffsetX();
    }
  }
  return r;
}

const CLHEP::Hep3Vector GeometryPar::getScintEnvelopeOffset(int layer, bool hasChimney) const
{
  CLHEP::Hep3Vector airHalfSize = getAirHalfSize(layer, hasChimney);
  CLHEP::Hep3Vector envelopeHalfSize = getScintEnvelopeHalfSize(layer, hasChimney);
  CLHEP::Hep3Vector offset((airHalfSize.x() - envelopeHalfSize.x()),
                           (airHalfSize.y() - envelopeHalfSize.y()),
                           -(airHalfSize.z() - envelopeHalfSize.z()));
  return offset;
}

const CLHEP::Hep3Vector GeometryPar::getChimneyHalfSize(int layer) const
{
  return CLHEP::Hep3Vector(0.5 * (getLayerOuterRadius(layer) - getLayerInnerRadius(layer)),
                           0.5 * m_ChimneyWidth,
                           0.5 * (m_ChimneyLength - m_ChimneyCoverThickness));
}

const CLHEP::Hep3Vector GeometryPar::getChimneyPosition(int layer) const
{
  return CLHEP::Hep3Vector(0.5 * (getLayerOuterRadius(layer) + getLayerInnerRadius(layer)),
                           0.0,
                           0.5 * (m_GapLength - m_ChimneyLength - m_ChimneyCoverThickness));
}

const CLHEP::Hep3Vector GeometryPar::getSupportPlateHalfSize(bool hasChimney) const
{
  CLHEP::Hep3Vector size;
  size.setX(0.5 * m_SupportPlateHeight);
  size.setY(0.5 * m_SupportPlateWidth);
  if (hasChimney) {
    size.setZ(0.5 * m_SupportPlateLengthChimney);
  } else {
    size.setZ(0.5 * m_SupportPlateLength);
  }
  return size;
}

double GeometryPar::getBracketZPosition(int bracket, bool hasChimney) const
{
  double z = m_BracketInset - 0.5 * m_GapLength;
  if (bracket == 0)
    return z;
  if (hasChimney) {
    return m_SupportPlateLengthChimney - m_GapLength - z;
  } else {
    return (bracket == 1 ? 0.0 : -z);
  }
}

const CLHEP::Hep3Vector GeometryPar::getReadoutContainerHalfSize(void) const
{
  return CLHEP::Hep3Vector(0.5 * m_ReadoutContainerWidth,
                           0.5 * m_ReadoutContainerLength,
                           0.5 * m_ReadoutContainerHeight
                          );
}

const CLHEP::Hep3Vector GeometryPar::getReadoutCarrierHalfSize(void) const
{
  return CLHEP::Hep3Vector(0.5 * m_ReadoutCarrierWidth,
                           0.5 * m_ReadoutCarrierLength,
                           0.5 * m_ReadoutCarrierHeight
                          );
}

const CLHEP::Hep3Vector GeometryPar::getReadoutPreamplifierHalfSize(void) const
{
  return CLHEP::Hep3Vector(0.5 * m_ReadoutPreamplifierWidth,
                           0.5 * m_ReadoutPreamplifierLength,
                           0.5 * m_ReadoutPreamplifierHeight
                          );
}

const CLHEP::Hep3Vector GeometryPar::getReadoutConnectorsHalfSize(void) const
{
  return CLHEP::Hep3Vector(0.5 * m_ReadoutConnectorsWidth,
                           0.5 * m_ReadoutConnectorsLength,
                           0.5 * m_ReadoutConnectorsHeight
                          );
}

bool GeometryPar::hasRPCs(int layer) const
{
  if ((layer <= 0) || (layer > m_NLayer))
    return false;
  return m_HasRPCs[layer - 1];
}

const Module* GeometryPar::findModule(int section, int sector, int layer) const
{
  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
  std::map<int, Module*>::const_iterator iM = m_Modules.find(moduleID);
  return (iM == m_Modules.end() ? nullptr : iM->second);
}

const HepGeom::Transform3D GeometryPar::getModuleAlignment(int section, int sector, int layer) const
{
  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
  std::map<int, HepGeom::Transform3D>::const_iterator iA = m_Alignments.find(moduleID);
  return (iA == m_Alignments.end() ? HepGeom::Transform3D() : iA->second);
}

const HepGeom::Transform3D GeometryPar::getModuleDisplacedGeo(int section, int sector, int layer) const
{
  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
  std::map<int, HepGeom::Transform3D>::const_iterator iDis = m_Displacements.find(moduleID);
  return (iDis == m_Displacements.end() ? HepGeom::Transform3D() : iDis->second);
}

void GeometryPar::readAlignmentFromDB()
{
  DBObjPtr<BKLMAlignment> bklmAlignment;
  if (!bklmAlignment.isValid())
    do { { LogVariableStream varStream; varStream << "No BKLM alignment data."; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 775, 0)); }; exit(1); } while(false);
  KLMChannelIndex bklmModules(KLMChannelIndex::c_IndexLevelLayer);
  for (KLMChannelIndex bklmModule = bklmModules.beginBKLM();
       bklmModule != bklmModules.endBKLM(); ++bklmModule) {
    KLMModuleNumber module = bklmModule.getKLMModuleNumber();
    const KLMAlignmentData* alignmentData =
      bklmAlignment->getModuleAlignment(module);
    if (alignmentData == nullptr)
      do { { LogVariableStream varStream; varStream << "Incomplete BKLM alignment data."; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 783, 0)); }; exit(1); } while(false);
    HepGeom::Transform3D alignment;
    alignment = getTransformFromRigidBodyParams(
                  alignmentData->getDeltaU(),
                  alignmentData->getDeltaV(),
                  alignmentData->getDeltaW(),
                  alignmentData->getDeltaAlpha(),
                  alignmentData->getDeltaBeta(),
                  alignmentData->getDeltaGamma());
    int moduleID = BKLMElementNumbers::moduleNumber(
                     bklmModule.getSection(), bklmModule.getSector(),
                     bklmModule.getLayer());
    m_Alignments.insert(std::pair<int, HepGeom::Transform3D>(moduleID, alignment));
  }

  bklmAlignment.addCallback(this, &bklm::GeometryPar::readAlignmentFromDB);
}

void GeometryPar::readDisplacedGeoFromDB()
{
  DBObjPtr<BKLMAlignment> bklmDisplacement("BKLMDisplacement");
  if (!bklmDisplacement.isValid())
    do { { LogVariableStream varStream; varStream << "No BKLM displaced geometry data in database!"; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 805, 0)); }; exit(1); } while(false);
  KLMChannelIndex bklmModules(KLMChannelIndex::c_IndexLevelLayer);
  for (KLMChannelIndex bklmModule = bklmModules.beginBKLM();
       bklmModule != bklmModules.endBKLM(); ++bklmModule) {
    KLMModuleNumber module = bklmModule.getKLMModuleNumber();
    const KLMAlignmentData* displacementData =
      bklmDisplacement->getModuleAlignment(module);
    if (displacementData == nullptr)
      do { { LogVariableStream varStream; varStream << "Incomplete BKLM displacement data."; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig::c_Fatal, std::move(varStream), "klm", __PRETTY_FUNCTION__, "klm/bklm/geometry/src/GeometryPar.cc", 813, 0)); }; exit(1); } while(false);
    HepGeom::Transform3D displacement;
    displacement = getTransformFromRigidBodyParams(
                     displacementData->getDeltaU(),
                     displacementData->getDeltaV(),
                     displacementData->getDeltaW(),
                     displacementData->getDeltaAlpha(),
                     displacementData->getDeltaBeta(),
                     displacementData->getDeltaGamma());
    int moduleID = BKLMElementNumbers::moduleNumber(
                     bklmModule.getSection(), bklmModule.getSector(),
                     bklmModule.getLayer());
    m_Displacements.insert(std::pair<int, HepGeom::Transform3D>(moduleID, displacement));
  }

  bklmDisplacement.addCallback(this, &bklm::GeometryPar::readDisplacedGeoFromDB);
}

HepGeom::Transform3D GeometryPar::getTransformFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta,
    double dGamma)
{

  CLHEP::HepRotation dy = CLHEP::HepRotationY(-dAlpha);
  CLHEP::HepRotation dz = CLHEP::HepRotationZ(-dBeta);
  CLHEP::HepRotation dx = CLHEP::HepRotationX(-dGamma);
  CLHEP::Hep3Vector shift(dW, dU, dV);




  return HepGeom::Transform3D(dy * dz * dx, shift);
}